diff --git a/.github/workflows/fiber-stable-action.yml b/.github/workflows/fiber-stable-action.yml new file mode 100644 index 0000000..76ec1dc --- /dev/null +++ b/.github/workflows/fiber-stable-action.yml @@ -0,0 +1,63 @@ +# This workflow will install Python dependencies, run tests and lint with a single version of Python +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python + +name: fiber stable action +on: + workflow_dispatch: # Allows the workflow to be manually triggered + inputs: + GitUrl: + description: 'fiber -git url' + default: 'https://github.com/nervosnetwork/fiber.git' + GitBranch: + description: 'fiber -git branch' + default: 'develop' + BuildFIBER: + description: 'build fiber' + default: 'true' + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-22.04 + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.12 + uses: actions/setup-python@v3 + with: + python-version: "3.12" + + - name: Print Input Values + run: | + echo "**Input Values:**" + echo " GitUrl: ${{ github.event.inputs.GitUrl }}" + echo " GitBranch: ${{ github.event.inputs.GitBranch }}" + echo " BuildCKbCLI: ${{ github.event.inputs.BuildFIBER }}" + + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + + - name: Install dependencies + run: make prepare_develop_testnet + env: + GitUrl: '${{ github.event.inputs.GitUrl }}' + GitBranch: '${{ github.event.inputs.GitBranch }}' + BuildFIBER: '${{ github.event.inputs.BuildFIBER }}' + + - name: Run tests + run: make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/devnet/stable" + + # - name: Setup upterm session + # if: always() + # uses: lhotari/action-upterm@v1 + + - name: Publish reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: jfoa-build-reports-${{ runner.os }} + path: ./report diff --git a/.github/workflows/fiber-testnet.yml b/.github/workflows/fiber-testnet.yml index b18e330..dbd7ec4 100644 --- a/.github/workflows/fiber-testnet.yml +++ b/.github/workflows/fiber-testnet.yml @@ -28,10 +28,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Print Input Values run: | diff --git a/.github/workflows/fiber.yml b/.github/workflows/fiber.yml index e8e6755..ec4c3fa 100644 --- a/.github/workflows/fiber.yml +++ b/.github/workflows/fiber.yml @@ -17,10 +17,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -49,10 +49,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -79,16 +79,16 @@ jobs: name: jfoa-open_channel-reports-${{ runner.os }} path: ./report - fiber_test_accept_channel_cancel_invoice_connect_peer_disconnect_peer: + fiber_test_accept_channel_cancel_invoice_connect_peer_disconnect_peer_backup: needs: prepare runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -106,7 +106,7 @@ jobs: tar -xzf prepare-backup.tar.gz - name: Run fiber_test_demo - run: make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/devnet/accept_channel test_cases/fiber/devnet/cancel_invoice test_cases/fiber/devnet/connect_peer test_cases/fiber/devnet/disconnect_peer" + run: make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/devnet/accept_channel test_cases/fiber/devnet/cancel_invoice test_cases/fiber/devnet/connect_peer test_cases/fiber/devnet/disconnect_peer test_cases/fiber/devnet/backup" - name: Publish reports if: failure() @@ -121,10 +121,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -157,10 +157,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -193,10 +193,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -230,10 +230,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -267,10 +267,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -303,10 +303,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -340,10 +340,10 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.12 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.12" - name: Install dependencies run: | @@ -369,3 +369,121 @@ jobs: with: name: jfoa-fiber_test_send_payment_debug_mixed-reports-${{ runner.os }} path: ./report + + fiber_test_wasm: + needs: prepare + runs-on: ubuntu-22.04 + + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.12 + uses: actions/setup-python@v3 + with: + python-version: "3.12" + - name: Set up Node.js + uses: actions/setup-node@v3 + with: + node-version: '18' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + + - name: Download prepare backup + uses: actions/download-artifact@v4 + with: + name: prepare-backup-${{ runner.os }} + path: ./ + + - name: Extract tarball and restore permissions + run: | + tar -xzf prepare-backup.tar.gz + - name: prepare wasm env + run: | + git clone https://github.com/gpBlockchain/fiber-wasm-demo.git + cd fiber-wasm-demo + bash prepare.sh + cd ../ + - name: Run fiber_test_demo + run: | + make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/devnet/wasm" + + - name: Publish reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: jfoa-fiber_test_send_payment_debug_mixed-reports-${{ runner.os }} + path: ./report + + fiber_test_send_payment_mpp: + needs: prepare + runs-on: ubuntu-22.04 + + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.12 + uses: actions/setup-python@v3 + with: + python-version: "3.12" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + + - name: Download prepare backup + uses: actions/download-artifact@v4 + with: + name: prepare-backup-${{ runner.os }} + path: ./ + + - name: Extract tarball and restore permissions + run: | + tar -xzf prepare-backup.tar.gz + + - name: Run fiber_test_demo + run: make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/devnet/send_payment/mpp" + + - name: Publish reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: jfoa-fiber_test_send_payment_debug_mixed-reports-${{ runner.os }} + path: ./report + + fiber_test_BiscuitAuth_config: + needs: prepare + runs-on: ubuntu-22.04 + + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.12 + uses: actions/setup-python@v3 + with: + python-version: "3.12" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + + - name: Download prepare backup + uses: actions/download-artifact@v4 + with: + name: prepare-backup-${{ runner.os }} + path: ./ + + - name: Extract tarball and restore permissions + run: | + tar -xzf prepare-backup.tar.gz + + - name: Run fiber_test_demo + run: make fiber_test_demo FIBER_TEST_DEMO="test_cases/fiber/BiscuitAuth test_cases/fiber/config" + + - name: Publish reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: jfoa-fiber_test_send_payment_debug_mixed-reports-${{ runner.os }} + path: ./report diff --git a/.gitignore b/.gitignore index 5be01bc..b65e17d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,5 @@ # Created by pytest automatically. -tmp +tmp1 .pytest_cache download pytest.ini diff --git a/Makefile b/Makefile index 50447be..84087ef 100644 --- a/Makefile +++ b/Makefile @@ -24,7 +24,7 @@ prepare_fiber_testnet: python3 -m download_ckb_light_client echo "install ckb cli" python3 -m download_fiber - cp download/0.119.0/ckb-cli ./source/ckb-cli + cp download/0.201.0/ckb-cli ./source/ckb-cli cp download/0.110.2/ckb-cli ./source/ckb-cli-old prepare_develop_testnet: @@ -37,7 +37,7 @@ prepare_develop_testnet: echo "install fiber" python3 -m download_fiber - cp download/0.119.0/ckb-cli ./source/ckb-cli + cp download/0.201.0/ckb-cli ./source/ckb-cli cp download/0.110.2/ckb-cli ./source/ckb-cli-old bash develop_fiber.sh @@ -169,12 +169,10 @@ develop_test: clean: - pkill ckb - rm -rf tmp - rm -rf download - rm -rf report - rm -rf source/ckb-cli* - rm -rf ckb-* + - pkill ckb + - pkill fnn + - rm -rf tmp + - rm -rf report docs: python -m pytest --docs=docs/soft.md --doc-type=md test_cases/soft_fork diff --git a/develop_fiber.sh b/develop_fiber.sh index 39e3667..b2f378e 100644 --- a/develop_fiber.sh +++ b/develop_fiber.sh @@ -16,8 +16,8 @@ BUILD_FIBER="${BuildFIBER:-$DEFAULT_BUILD_FIBER}" if [ "$BUILD_FIBER" == "true" ]; then git clone -b $GitFIBERBranch $GitFIBERUrl cd fiber - cargo build - cp target/debug/fnn ../download/fiber/current/fnn + cargo build --release + cp target/release/fnn ../download/fiber/current/fnn cd migrate cargo build cp target/debug/fnn-migrate ../../download/fiber/current/fnn-migrate diff --git a/download.py b/download.py index d0cb684..60224a5 100644 --- a/download.py +++ b/download.py @@ -12,17 +12,9 @@ from tqdm import tqdm versions = [ - "0.109.0", "0.110.2", - "0.111.0", - "0.112.1", - "0.113.1", - "0.114.0", - "0.115.0", - "0.116.1", "0.117.0", - "0.118.0", - "0.119.0-rc1", + "0.201.0", ] # Replace with your versions DOWNLOAD_DIR = "download" diff --git a/download_fiber.py b/download_fiber.py index a0db1e7..e95727e 100644 --- a/download_fiber.py +++ b/download_fiber.py @@ -12,14 +12,9 @@ from tqdm import tqdm versions = [ - "0.2.0", - "0.2.1", - "0.3.0", - "0.3.1", - "0.4.0", - "0.4.2", "0.5.0", "0.5.1", + "0.6.0-rc5", ] # Replace with your versions DOWNLOAD_DIR = "download/fiber" diff --git a/framework/basic_fiber.py b/framework/basic_fiber.py index 2fa2704..48935b6 100644 --- a/framework/basic_fiber.py +++ b/framework/basic_fiber.py @@ -3,15 +3,19 @@ from framework.helper.udt_contract import UdtContract, issue_udt_tx from framework.test_fiber import Fiber, FiberConfigPath -from framework.util import generate_account_privakey -from framework.util import ACCOUNT_PRIVATE_KEY_INDEX +from framework.util import generate_account_privakey, get_project_root +from framework.util import run_command import time import random -import datetime -from framework.util import ( - to_int_from_big_uint128_le, -) +from datetime import datetime +from framework.util import to_int_from_big_uint128_le, change_time import logging +import os +import subprocess + +# FIBER_TAR_GZ = "ckb-py-integration-test/source/fiber/data.fiber.tar.gz" +XUDT_TX_HASH = "0x03c4475655a46dc4984c49fce03316f80bf666236bd95118112731082758d686" +XUDT_CODE_HASH = "0x102583443ba6cfe5a3ac268bbb4475fb63eb497dce077f126ad3b148d4f4f8f8" class FiberTest(CkbTest): @@ -25,6 +29,7 @@ class FiberTest(CkbTest): fiber_version = FiberConfigPath.CURRENT_DEV logger = logging.getLogger(__name__) start_fiber_config = {} + fnn_log_level = "debug" @classmethod def setup_class(cls): @@ -46,7 +51,7 @@ def setup_class(cls): cls.account2_private_key ) cls.node = cls.CkbNode.init_dev_by_port( - cls.CkbNodeConfigPath.CURRENT_FIBER, "contract/node", 8114, 8125 + cls.CkbNodeConfigPath.CURRENT_TEST, "contract/node", 8114, 8125 ) if cls.debug: @@ -58,9 +63,11 @@ def setup_class(cls): cls.first_debug = True cls.node.prepare() + tar_file( + f"{get_project_root()}/source/fiber/data.fiber.tar.gz", cls.node.ckb_dir + ) cls.node.start() cls.node.getClient().get_consensus() - cls.Miner.make_tip_height_number(cls.node, 20) def setup_method(cls, method): """ @@ -92,12 +99,8 @@ def setup_method(cls, method): ) cls.fibers.append(cls.fiber1) cls.fibers.append(cls.fiber2) - # # deploy xudt - xudt_contract_hash = cls.node.getClient().get_block_by_number("0x0")[ - "transactions" - ][0]["hash"] # - cls.udtContract = UdtContract(xudt_contract_hash, 9) + cls.udtContract = UdtContract(XUDT_TX_HASH, 0) # deploy_hash, deploy_index = cls.udtContract.get_deploy_hash_and_index() @@ -130,10 +133,10 @@ def setup_method(cls, method): update_config.update(cls.start_fiber_config) cls.fiber1.prepare(update_config=update_config) - cls.fiber1.start() + cls.fiber1.start(fnn_log_level=cls.fnn_log_level) cls.fiber2.prepare(update_config=update_config) - cls.fiber2.start() + cls.fiber2.start(fnn_log_level=cls.fnn_log_level) before_balance1 = cls.Ckb_cli.wallet_get_capacity( cls.account1["address"]["testnet"], api_url=cls.node.getClient().url ) @@ -250,16 +253,22 @@ def start_new_fiber( account_private_key, f"fiber/node{3 + i}", str(8251 + i), - str(8302 + i), + str(8402 + i), ) self.fibers.append(fiber) self.new_fibers.append(fiber) fiber.prepare(update_config=update_config) - fiber.start() + fiber.start(fnn_log_level=self.fnn_log_level) return fiber def wait_for_channel_state( - self, client, peer_id, expected_state, timeout=120, include_closed=False + self, + client, + peer_id, + expected_state, + timeout=120, + include_closed=False, + channel_id=None, ): """Wait for a channel to reach a specific state. 1. NEGOTIATING_FUNDING @@ -274,13 +283,30 @@ def wait_for_channel_state( if len(channels["channels"]) == 0: time.sleep(1) continue - if channels["channels"][0]["state"]["state_name"] == expected_state: - self.logger.debug(f"Channel reached expected state: {expected_state}") - # todo wait broading - time.sleep(2) - return channels["channels"][0]["channel_id"] + idx = 0 + if channel_id is not None: + for i in range(len(channels["channels"])): + print("channel_id:", channel_id) + if channels["channels"][i]["channel_id"] == channel_id: + idx = i + if type(expected_state) == str: + if channels["channels"][idx]["state"]["state_name"] == expected_state: + self.logger.debug( + f"Channel reached expected state: {expected_state}" + ) + # todo wait broading + time.sleep(1) + return channels["channels"][idx]["channel_id"] + if type(expected_state) == dict: + if channels["channels"][idx]["state"] == expected_state: + self.logger.debug( + f"Channel reached expected state: {expected_state}" + ) + # todo wait broading + time.sleep(1) + return channels["channels"][idx]["channel_id"] self.logger.debug( - f"Waiting for channel state: {expected_state}, current state: {channels['channels'][0]['state']['state_name']}" + f"Waiting for channel state: {expected_state}, current state: {channels['channels'][0]['state']}" ) time.sleep(1) raise TimeoutError( @@ -304,6 +330,7 @@ def open_channel( fiber1_fee=1000, fiber2_fee=1000, udt=None, + other_config={}, ): fiber1.connect_peer(fiber2) time.sleep(1) @@ -313,14 +340,14 @@ def open_channel( ], 16, ): - temporary_channel = fiber1.get_client().open_channel( - { - "peer_id": fiber2.get_peer_id(), - "funding_amount": hex(fiber1_balance + 62 * 100000000), - "tlc_fee_proportional_millionths": hex(fiber1_fee), - "public": True, - } - ) + open_channel_config = { + "peer_id": fiber2.get_peer_id(), + "funding_amount": hex(fiber1_balance + 62 * 100000000), + "tlc_fee_proportional_millionths": hex(fiber1_fee), + "public": True, + } + open_channel_config.update(other_config) + temporary_channel = fiber1.get_client().open_channel(open_channel_config) time.sleep(1) fiber2.get_client().accept_channel( { @@ -334,15 +361,15 @@ def open_channel( fiber1.get_client(), fiber2.get_peer_id(), "CHANNEL_READY" ) return - fiber1.get_client().open_channel( - { - "peer_id": fiber2.get_peer_id(), - "funding_amount": hex(fiber1_balance + fiber2_balance + 62 * 100000000), - "tlc_fee_proportional_millionths": hex(fiber1_fee), - "public": True, - "funding_udt_type_script": udt, - } - ) + open_channel_config = { + "peer_id": fiber2.get_peer_id(), + "funding_amount": hex(fiber1_balance + fiber2_balance + 62 * 100000000), + "tlc_fee_proportional_millionths": hex(fiber1_fee), + "public": True, + "funding_udt_type_script": udt, + } + open_channel_config.update(other_config) + fiber1.get_client().open_channel(open_channel_config) self.wait_for_channel_state( fiber1.get_client(), fiber2.get_peer_id(), "CHANNEL_READY" ) @@ -354,13 +381,15 @@ def open_channel( # "keysend": True, # } # ) - self.send_payment(fiber1, fiber2, fiber2_balance, True, udt, 10) - fiber2.get_client().update_channel( - { - "channel_id": channels["channels"][0]["channel_id"], - "tlc_fee_proportional_millionths": hex(fiber2_fee), - } - ) + if fiber2_balance != 0: + self.send_payment(fiber1, fiber2, fiber2_balance, True, udt, 10) + if fiber2_fee != 1000: + fiber2.get_client().update_channel( + { + "channel_id": channels["channels"][0]["channel_id"], + "tlc_fee_proportional_millionths": hex(fiber2_fee), + } + ) # self.wait_payment_state(fiber1, payment["payment_hash"], "Success") # channels = fiber1.get_client().list_channels({"peer_id": fiber2.get_peer_id()}) # assert channels["channels"][0]["local_balance"] == hex(fiber1_balance) @@ -374,18 +403,27 @@ def send_invoice_payment( "amount": hex(amount), "currency": "Fibd", "description": "test invoice generated by node2", - "expiry": "0xe10", - "final_cltv": "0x28", "payment_preimage": self.generate_random_preimage(), "hash_algorithm": "sha256", "udt_type_script": udt, + "allow_mpp": True, } ) for i in range(try_count): + # payment = fiber1.get_client().send_payment( + # { + # "invoice": invoice["invoice_address"], + # "allow_self_payment": True, + # "dry_run": True, + # "max_parts":"0x40", + # } + # ) try: payment = fiber1.get_client().send_payment( { "invoice": invoice["invoice_address"], + "allow_self_payment": True, + "max_parts": "0x40", } ) if wait: @@ -397,6 +435,8 @@ def send_invoice_payment( payment = fiber1.get_client().send_payment( { "invoice": invoice["invoice_address"], + "allow_self_payment": True, + "max_parts": "0x40", } ) if wait: @@ -413,10 +453,13 @@ def send_payment(self, fiber1, fiber2, amount, wait=True, udt=None, try_count=5) "keysend": True, "allow_self_payment": True, "udt_type_script": udt, + # "final_tlc_expiry_delta": hex(120960000), } ) if wait: - self.wait_payment_state(fiber1, payment["payment_hash"], "Success") + self.wait_payment_state( + fiber1, payment["payment_hash"], "Success", 600, 0.1 + ) return payment["payment_hash"] except Exception as e: time.sleep(1) @@ -431,7 +474,9 @@ def send_payment(self, fiber1, fiber2, amount, wait=True, udt=None, try_count=5) } ) if wait: - self.wait_payment_state(fiber1, payment["payment_hash"], "Success") + self.wait_payment_state( + fiber1, payment["payment_hash"], "Success", 600, 0.1 + ) return payment["payment_hash"] def get_account_script(self, account_private_key): @@ -442,14 +487,18 @@ def get_account_script(self, account_private_key): "args": account1["lock_arg"], } - def wait_payment_state(self, client, payment_hash, status="Success", timeout=360): + def wait_payment_state( + self, client, payment_hash, status="Success", timeout=360, interval=1 + ): for i in range(timeout): result = client.get_client().get_payment({"payment_hash": payment_hash}) if result["status"] == status: return - time.sleep(1) + if result["status"] == "Failed" or result["status"] == "Success": + raise Exception(f"payment failed, reason:{result['status']}") + time.sleep(interval) raise TimeoutError( - f"status did not reach state: {status} within timeout period." + f"payment:{payment_hash} status did not reach state: {result['status']}, expected:{status} , within timeout period." ) def wait_payment_finished(self, client, payment_hash, timeout=120): @@ -467,15 +516,76 @@ def get_fibers_balance_message(self): for fiber in self.fibers: messages.append(self.get_fiber_balance(fiber)) for i in range(len(messages)): - self.logger.debug(f"fiber{i} balance:{messages[i]}") + self.logger.info(f"fiber{i} balance:{messages[i]}") + + def get_fiber_graph_balance(self): + """显示fiber网络中所有通道的余额信息""" + # 初始化节点映射表 + peer_id_map = {} + idx = 0 + for fiber in self.fibers: + peer_id = fiber.get_peer_id() + peer_id_map[peer_id] = idx + idx += 1 + + # 初始化通道映射表 + channel_maps = {} + for i in range(len(self.fibers)): + channel_maps[i] = {} + for j in range(len(self.fibers)): + channel_maps[i][j] = {} + + datas = {} + # 遍历所有fiber节点获取通道信息 + for fiber in self.fibers: + peer_id = fiber.get_peer_id() + channels = fiber.get_client().list_channels({}) + + # 遍历该节点的所有通道 + for channel in channels["channels"]: + remote_peer_id = channel["peer_id"] + # 记录通道信息到映射表 + # channel_maps[peer_id_map[peer_id]][peer_id_map[remote_peer_id]][channel['channel_id']] = { + # 'local_balance': int(channel["local_balance"], 16), + # 'remote_balance': int(channel["remote_balance"], 16), + # 'offered_balance': int(channel["offered_tlc_balance"], 16), + # 'received_balance': int(channel["received_tlc_balance"], 16), + # 'udt_type_script': channel.get("funding_udt_type_script", None), + # 'state': channel["state"]["state_name"] + # } + # self.logger.debug( + # f"{channel['channel_id']}-{peer_id_map[peer_id]}({int(channel["local_balance"], 16)},{int(channel["offered_tlc_balance"], 16)})-{peer_id_map[remote_peer_id]}({int(channel["remote_balance"], 16)},{int(channel["received_tlc_balance"], 16)}),udt_type_script:{channel.get("funding_udt_type_script", None)}") + # datas.append(f"{channel['channel_id']}-{peer_id_map[peer_id]}({int(channel["local_balance"], 16)},{int(channel["offered_tlc_balance"], 16)})-{peer_id_map[remote_peer_id]}({int(channel["remote_balance"], 16)},{int(channel["received_tlc_balance"], 16)}),udt_type_script:{channel.get("funding_udt_type_script", None)}") + datas[channel["channel_id"]] = ( + f"{channel['channel_id']}-{peer_id_map[peer_id]}({int(channel["local_balance"], 16) / 100000000},{int(channel["offered_tlc_balance"], 16) / 100000000})-{peer_id_map[remote_peer_id]}({int(channel["remote_balance"], 16) / 100000000},{int(channel["received_tlc_balance"], 16) / 100000000}),udt_type_script:{channel.get("funding_udt_type_script", None)}" + ) + for key in datas: + self.logger.debug(f"{key}:{datas[key]}") + # self.logger.debug(datas[key]) def get_fiber_balance(self, fiber): channels = fiber.get_client().list_channels({}) balance_map = {} - channels_balance = 0 - channels_offered_tlc_balance = 0 - channels_received_tlc_balance = 0 + lock_script = self.get_account_script(fiber.account_private) + + chain_udt_balance = self.udtContract.balance( + self.node.getClient(), + self.fiber1.account_private, + lock_script["args"], + ) + + chain_ckb_balance = int( + self.node.getClient().get_cells_capacity( + { + "script": lock_script, + "script_type": "lock", + "script_search_mode": "exact", + } + )["capacity"], + 16, + ) + for i in range(len(channels["channels"])): channel = channels["channels"][i] if channel["state"]["state_name"] == "CHANNEL_READY": @@ -495,6 +605,9 @@ def get_fiber_balance(self, fiber): balance_map[key]["received_tlc_balance"] += int( channel["received_tlc_balance"], 16 ) + balance_map["chain"] = {} + balance_map["chain"]["ckb"] = chain_ckb_balance + balance_map["chain"]["udt"] = chain_udt_balance return balance_map def calculate_tx_fee(self, balance, fee_list): @@ -815,6 +928,124 @@ def wait_fibers_pending_tlc_eq0(self, fiber, wait_times=30): return raise TimeoutError(f"{fiber_balance}") + def wait_graph_channels_sync(self, fiber, channels_count, timeout=120): + """ + 等待图形通道同步 + :param fiber: Fiber实例 + :param channels_count: 期望的通道数量 + :param timeout: 超时时间，单位为秒 + """ + for i in range(timeout): + graph_channels = fiber.get_client().graph_channels()["channels"] + if len(graph_channels) == channels_count: + print(f"Graph channels synced successfully,cost time:{i}") + return True + time.sleep(1) + raise TimeoutError( + f"Graph channels did not sync to {channels_count} within {timeout} seconds." + ) + + def add_time_and_generate_epoch(self, hour, epoch): + change_time(hour) + client = self.node.getClient() + header = client.get_tip_header() + before_median_time = client.get_block_median_time(header["hash"]) + self.node.getClient().generate_epochs(hex(epoch), 0) + header = client.get_tip_header() + median_time = client.get_block_median_time(header["hash"]) + print( + "before_median_time datetime:", + datetime.fromtimestamp(int(before_median_time, 16) / 1000), + ) + print( + "median_time datetime:", datetime.fromtimestamp(int(median_time, 16) / 1000) + ) + + def add_time_and_generate_block(self, hour, block_num): + change_time(hour) + client = self.node.getClient() + header = client.get_tip_header() + before_median_time = client.get_block_median_time(header["hash"]) + for i in range(block_num): + self.Miner.miner_with_version(self.node, "0x0") + header = client.get_tip_header() + median_time = client.get_block_median_time(header["hash"]) + print( + "before_median_time datetime:", + datetime.fromtimestamp(int(before_median_time, 16) / 1000), + ) + print( + "median_time datetime:", datetime.fromtimestamp(int(median_time, 16) / 1000) + ) + + def get_commit_cells(self): + # code_hash: 0x2d7d93e3347ddf9f10f6690af75f1e24debaa6c4363f3b2c068f61c757253d38 + # hash_type: type + # args: 0x + return self.node.getClient().get_cells( + { + "script": { + "code_hash": "0x2d7d93e3347ddf9f10f6690af75f1e24debaa6c4363f3b2c068f61c757253d38", + "hash_type": "type", + "args": "0x", + }, + "script_type": "lock", + "script_search_mode": "prefix", + }, + "asc", + "0xfff", + None, + )["objects"] + + def restore_time(self): + """恢复系统时间""" + print("开始恢复系统时间...") + print("current time:", time.time()) + print("current datetime:", datetime.now()) + + try: + # 检测是否在Docker容器中运行 + is_docker = os.path.exists("/.dockerenv") + + if is_docker: + # 在Docker容器中，尝试从网络同步时间 + cmd = "ntpdate -s time.nist.gov" + print(f"Docker环境 - 执行命令: {cmd}") + else: + # 在宿主机上，使用sntp同步网络时间 + cmd = f"echo hyperchain | sudo -S sntp -sS time.apple.com" + print(f"宿主机环境 - 执行命令: sudo sntp -sS time.apple.com") + + # 执行系统命令 + result = subprocess.run(cmd, shell=True, capture_output=True, text=True) + + if result.returncode == 0: + print("系统时间恢复成功") + else: + print(f"系统时间恢复失败: {result.stderr}") + # 如果网络同步失败，尝试手动减去1小时 + print("尝试手动恢复时间（减去1小时）...") + current_time = datetime.now() + restore_time_dt = current_time - timedelta(hours=1) + time_str = restore_time_dt.strftime("%m%d%H%M%Y") + + if is_docker: + cmd = f"date {time_str}" + else: + cmd = f"echo '{password}' | sudo -S date {time_str}" + + result = subprocess.run(cmd, shell=True, capture_output=True, text=True) + if result.returncode == 0: + print("手动时间恢复成功") + else: + print(f"手动时间恢复失败: {result.stderr}") + + except Exception as e: + print(f"恢复系统时间时发生错误: {e}") + + print("restored time:", time.time()) + print("restored datetime:", datetime.now()) + def check_port(port): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: @@ -824,3 +1055,7 @@ def check_port(port): return True # 端口开放 except (socket.timeout, socket.error): return False # 端口未开放 + + +def tar_file(src_tar, dec_data): + run_command(f"tar -xvf {src_tar} -C {dec_data}") diff --git a/framework/fiber_rpc.py b/framework/fiber_rpc.py index c56d3d3..267d949 100644 --- a/framework/fiber_rpc.py +++ b/framework/fiber_rpc.py @@ -10,8 +10,10 @@ class FiberRPCClient: - def __init__(self, url): + def __init__(self, url, other_params={}, try_count=200): self.url = url + self.other_params = other_params + self.try_count = try_count def send_btc(self, btc_pay_req): return self.call("send_btc", [btc_pay_req]) @@ -213,13 +215,14 @@ def list_peers(self): def call(self, method, params): headers = {"content-type": "application/json"} + headers.update(self.other_params) data = {"id": 42, "jsonrpc": "2.0", "method": method, "params": params} LOGGER.debug( "curl --location '{url}' --header 'Content-Type: application/json' --data '{data}'".format( url=self.url, data=json.dumps(data, indent=4) ) ) - for i in range(200): + for i in range(self.try_count): try: response = requests.post( self.url, data=json.dumps(data), headers=headers diff --git a/framework/test_fiber.py b/framework/test_fiber.py index 1f17213..521a72c 100644 --- a/framework/test_fiber.py +++ b/framework/test_fiber.py @@ -17,34 +17,25 @@ class FiberConfigPath(Enum): CURRENT_DEV = ( - "/source/template/fiber/dev_config_2.yml.j2", + "/source/fiber/dev_config.yml.j2", # "download/fiber/0.5.0/fnn", "download/fiber/current/fnn", ) CURRENT_DEV_DEBUG = ( - "/source/template/fiber/dev_config_2.yml.j2", + "/source/fiber/dev_config.yml.j2", "download/fiber/current/fnn.debug", ) CURRENT_TESTNET = ( "/source/template/fiber/testnet_config_2.yml.j2", - "download/fiber/0.5.1/fnn", + "download/fiber/0.6.0/fnn", ) - V042_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.4.2/fnn") - V040_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.4.0/fnn") - V031_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.3.1/fnn") - V030_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.3.0/fnn") - V020_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.2.0/fnn") - V010_TESTNET = ("/source/template/fiber/config.yml.j2", "download/fiber/0.1.0/fnn") - - V040_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.4.0/fnn") - V031_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.3.1/fnn") - V030_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.3.0/fnn") - V021_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.2.1/fnn") - V020_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.2.0/fnn") - V010_DEV = ("/source/template/fiber/dev_config.yml.j2", "download/fiber/0.1.0/fnn") + V050_DEV = ( + "/source/template/fiber/dev_config_2.yml.j2", + "download/fiber/0.5.0/fnn", + ) def __init__(self, fiber_config_path, fiber_bin_path): self.fiber_config_path = fiber_config_path @@ -105,9 +96,7 @@ def prepare(self, update_config=None): self.fiber_config_path, ) shutil.copy( - "{root_path}/source/template/ckb/fiber/dev.toml".format( - root_path=get_project_root() - ), + "{root_path}/source/fiber/dev.toml".format(root_path=get_project_root()), self.tmp_path, ) target_dir = os.path.join(self.tmp_path, "ckb") @@ -182,23 +171,36 @@ def migration(self): f"echo YES | RUST_LOG=info,fnn=debug {get_project_root()}/{self.fiber_config_enum.fiber_bin_path}-migrate -p {self.tmp_path}/fiber/store" ) - def start(self, password="password0"): + def start( + self, + password="password0", + fnn_log_level="debug", + rpc_biscuit_public_key=None, + ): # env_map = dict(os.environ) # Make a copy of the current environment - # if node: + # if node:, # contract_map = self.get_contract_env_map(node) # env_map.update(contract_map) # for key in env_map: # print(f"{key}={env_map[key]}") + rpc_biscuit_public_key_option = "" + if rpc_biscuit_public_key != None: + rpc_biscuit_public_key_option = ( + f" --rpc-biscuit-public-key {rpc_biscuit_public_key}" + ) run_command( - f"FIBER_SECRET_KEY_PASSWORD='{password}' RUST_LOG=info,fnn=debug {get_project_root()}/{self.fiber_config_enum.fiber_bin_path} -c {self.tmp_path}/config.yml -d {self.tmp_path} > {self.tmp_path}/node.log 2>&1 &" + f" FIBER_SECRET_KEY_PASSWORD='{password}' RUST_LOG=info,fnn={fnn_log_level} {get_project_root()}/{self.fiber_config_enum.fiber_bin_path} -c {self.tmp_path}/config.yml -d {self.tmp_path} {rpc_biscuit_public_key_option} >> {self.tmp_path}/node.log 2>&1 &" # env=env_map, ) # wait rpc start - time.sleep(1) + time.sleep(0.1) print("start fiber client ") def stop(self): - run_command(f"kill $(lsof -t -i:{self.rpc_port})", False) + run_command( + "kill $(lsof -i:" + self.rpc_port + " | grep LISTEN | awk '{print $2}')", + False, + ) time.sleep(1) def force_stop(self): diff --git a/framework/test_node.py b/framework/test_node.py index 889284a..386a5ac 100644 --- a/framework/test_node.py +++ b/framework/test_node.py @@ -9,7 +9,6 @@ from framework.config import get_tmp_path, CKB_DEFAULT_CONFIG, CKB_MINER_CONFIG from framework.rpc import RPCClient import shutil -import telnetlib from websocket import create_connection, WebSocket import toml @@ -19,14 +18,14 @@ class CkbNodeConfigPath(Enum): "source/template/ckb/v118/ckb.toml.j2", "source/template/ckb/v118/ckb-miner.toml.j2", "source/template/ckb/v118/specs/dev.toml", - "download/0.120.0", + "download/0.201.0", ) CURRENT_FIBER = ( "source/template/ckb/v118/ckb.toml.j2", "source/template/ckb/v118/ckb-miner.toml.j2", "source/template/ckb/fiber/dev.toml", - "download/0.119.0", + "download/0.201.0", ) TESTNET = ( "source/template/ckb/v118/ckb.toml.j2", @@ -379,31 +378,32 @@ def list_hashes(self): data = toml.loads(ret) return data - def subscribe_telnet(self, topic, other_url=None) -> telnetlib.Telnet: + def subscribe_telnet(self, topic, other_url=None): + pass # new_tip_header | new_tip_block | new_transaction | proposed_transaction | rejected_transaction - if "ckb_tcp_listen_address" not in self.ckb_config.keys(): - raise Exception("not set ckb_ws_listen_address") - ckb_tcp_listen_address = self.ckb_config["ckb_tcp_listen_address"] - if other_url is not None: - ckb_tcp_listen_address = other_url - # get host - host = ckb_tcp_listen_address.split(":")[0] - # get port - port = ckb_tcp_listen_address.split(":")[1] - # new telnet - tn = telnetlib.Telnet(host, int(port)) - print("----") - topic_str = ( - '{"id": 2, "jsonrpc": "2.0", "method": "subscribe", "params": ["' - + topic - + '"]}' - ) - tn.write(topic_str.encode("utf-8") + b"\n") - data = tn.read_until(b"}\n") - if data: - output = data.decode("utf-8") - print("telnet read:", output) - return tn + # if "ckb_tcp_listen_address" not in self.ckb_config.keys(): + # raise Exception("not set ckb_ws_listen_address") + # ckb_tcp_listen_address = self.ckb_config["ckb_tcp_listen_address"] + # if other_url is not None: + # ckb_tcp_listen_address = other_url + # # get host + # host = ckb_tcp_listen_address.split(":")[0] + # # get port + # port = ckb_tcp_listen_address.split(":")[1] + # # new telnet + # tn = telnetlib.Telnet(host, int(port)) + # print("----") + # topic_str = ( + # '{"id": 2, "jsonrpc": "2.0", "method": "subscribe", "params": ["' + # + topic + # + '"]}' + # ) + # tn.write(topic_str.encode("utf-8") + b"\n") + # data = tn.read_until(b"}\n") + # if data: + # output = data.decode("utf-8") + # print("telnet read:", output) + # return tn def subscribe_websocket(self, topic, other_url=None) -> WebSocket: if other_url is None and "ckb_ws_listen_address" not in self.ckb_config.keys(): diff --git a/framework/test_wasm_fiber.py b/framework/test_wasm_fiber.py new file mode 100644 index 0000000..b9b2028 --- /dev/null +++ b/framework/test_wasm_fiber.py @@ -0,0 +1,119 @@ +from framework.fiber_rpc import FiberRPCClient + + +class WasmFiber: + + def __init__( + self, private_key, peer_id, type="devnet", debug=False, databasePrefix="default" + ): + self.private_key = private_key + self.peerId = peer_id + self.type = type + self.rppcClient = FiberRPCClient( + "http://localhost:9000", {"databaseprefix": databasePrefix} + ) + self.databasePrefix = databasePrefix + if debug: + return + if type == "testnet": + self.rppcClient.call( + "new_client", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "databasePrefix": self.databasePrefix, + } + ], + ) + elif type == "devnet": + self.rppcClient.call( + "new_client", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "devConfig": "dev-config.yml", + "databasePrefix": self.databasePrefix, + } + ], + ) + elif type == "devnet-watch-tower": + self.rppcClient.call( + "new_client", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "devConfig": "dev-config-watch-tower.yml", + "databasePrefix": self.databasePrefix, + } + ], + ) + + def stop(self): + self.rppcClient.call("stop", []) + + def start(self): + self.rppcClient.call("start", []) + + def refresh(self): + if self.type == "testnet": + self.rppcClient.call( + "refresh", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "databasePrefix": self.databasePrefix, + } + ], + ) + elif self.type == "devnet": + self.rppcClient.call( + "refresh", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "devConfig": "dev-config.yml", + "databasePrefix": self.databasePrefix, + } + ], + ) + elif self.type == "devnet-watch-tower": + self.rppcClient.call( + "refresh", + [ + { + "privateKey": self.private_key, + "peerId": self.peerId, + "devConfig": "dev-config-watch-tower.yml", + "databasePrefix": self.databasePrefix, + } + ], + ) + + def get_client(self): + return self.rppcClient + + def connect_peer(self, fiber): + node_info = fiber.get_client().node_info() + addresses = node_info["addresses"][0].split("/") + addresses[4] = f"{int(addresses[4])}/ws" + # peer_id = node_info["addresses"][1].split("/")[-1] + # peer_info = node_info["addresses"][0][""] + print(addresses) + self.rppcClient.connect_peer( + { + "address": "/".join(addresses), + } + ) + + @classmethod + def reset(cls, url="http://localhost:9000"): + """ + Reset the WasmFiber client. + """ + client = FiberRPCClient(url) + client.call("reset", []) diff --git a/framework/util.py b/framework/util.py index d031786..40ce066 100644 --- a/framework/util.py +++ b/framework/util.py @@ -14,7 +14,10 @@ U128_MAX_COMPATIBLE = 2**128 - 1 ACCOUNT_PRIVATE_KEY_INDEX = 0 import random - +import time +import subprocess +import os +from datetime import datetime, timedelta import logging LOGGER = logging.getLogger(__name__) @@ -209,6 +212,94 @@ def generate_account_privakey(): return f"{ACCOUNT_PRIVATE_KEY_INDEX}".zfill(64) +def change_time(hour): + # 修改系统时间,加速1h + try: + # 获取当前时间并加1小时 + current_time = datetime.now() + new_time = current_time + timedelta(hours=hour) + + # 格式化时间为系统命令需要的格式 + time_str = new_time.strftime("%m%d%H%M%Y") + + # 检测是否在Docker容器中运行 + is_docker = os.path.exists("/.dockerenv") + + if is_docker: + # 在Docker容器中使用date命令修改系统时间（不需要sudo） + cmd = f"date {time_str}" + print(f"Docker环境 - 执行命令: {cmd}") + else: + # 在宿主机上使用sudo date命令修改系统时间 + + cmd = f"echo hyperchain | sudo -S date {time_str}" + print(f"宿主机环境 - 执行命令: sudo date {time_str}") + + # 执行系统命令 + result = subprocess.run(cmd, shell=True, capture_output=True, text=True) + + if result.returncode == 0: + print("系统时间修改成功") + else: + print(f"系统时间修改失败: {result.stderr}") + + except Exception as e: + print(f"修改系统时间时发生错误: {e}") + + print("updated time:", time.time()) + print("updated datetime:", datetime.now()) + + +def restore_time(): + """恢复系统时间""" + print("开始恢复系统时间...") + print("current time:", time.time()) + print("current datetime:", datetime.now()) + + try: + # 检测是否在Docker容器中运行 + is_docker = os.path.exists("/.dockerenv") + + if is_docker: + # 在Docker容器中，尝试从网络同步时间 + cmd = "ntpdate -s time.nist.gov" + print(f"Docker环境 - 执行命令: {cmd}") + else: + # 在宿主机上，使用sntp同步网络时间 + cmd = f"echo hyperchain | sudo -S sntp -sS time.apple.com" + print(f"宿主机环境 - 执行命令: sudo sntp -sS time.apple.com") + + # 执行系统命令 + result = subprocess.run(cmd, shell=True, capture_output=True, text=True) + + if result.returncode == 0: + print("系统时间恢复成功") + else: + print(f"系统时间恢复失败: {result.stderr}") + # 如果网络同步失败，尝试手动减去1小时 + print("尝试手动恢复时间（减去1小时）...") + current_time = datetime.now() + restore_time_dt = current_time - timedelta(hours=1) + time_str = restore_time_dt.strftime("%m%d%H%M%Y") + + if is_docker: + cmd = f"date {time_str}" + else: + cmd = f"echo '{password}' | sudo -S date {time_str}" + + result = subprocess.run(cmd, shell=True, capture_output=True, text=True) + if result.returncode == 0: + print("手动时间恢复成功") + else: + print(f"手动时间恢复失败: {result.stderr}") + + except Exception as e: + print(f"恢复系统时间时发生错误: {e}") + + print("restored time:", time.time()) + print("restored datetime:", datetime.now()) + + if __name__ == "__main__": for i in range(100): account = generate_account_privakey() diff --git a/pytest.ini b/pytest.ini index 6b1de7d..6f0390e 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,11 +1,11 @@ [pytest] ;ci -addopts = --html=report/report.html +;addopts = --html=report/report.html ;debug -;addopts = -s +addopts = -s log_cli = 1 log_cli_level = INFO ;log_cli_level = DEBUG log_cli_format = %(asctime)s [%(filename)s:%(lineno)s][%(levelname)5s] %(message)s -log_cli_date_format=%Y-%m-%d %H:%M:%S \ No newline at end of file +log_cli_date_format=%Y-%m-%d %H:%M:%S diff --git a/source/fiber/README.md b/source/fiber/README.md new file mode 100644 index 0000000..252f05e --- /dev/null +++ b/source/fiber/README.md @@ -0,0 +1,11 @@ +xudt_code_hash: 0x102583443ba6cfe5a3ac268bbb4475fb63eb497dce077f126ad3b148d4f4f8f8 +xudt_tx_hash: 0x03c4475655a46dc4984c49fce03316f80bf666236bd95118112731082758d686 +auth_code_hash: 0x97959f53d36b73e86acb5e8b925d9f58ef255fce05b78625a308349f2df01c8a +auth_tx_hash: 0xecb1c1e3df6cd1e1ca16ca9bd392a3c030ece59cb5123bf156c51034e311a3ec +commitment_lock_code_hash: 0x2d7d93e3347ddf9f10f6690af75f1e24debaa6c4363f3b2c068f61c757253d38 +commitment_lock_tx_hash: 0x79c3e55d7010755918f3d9b464425692eee8aa2e9ce89e4355cac0caa51d95bf +funding_lock_code_hash: 0xd7302abe337c459b84c9da6d739d7736d6e8dbfd2326a509981c35943cfe0f56 +funding_lock_tx_hash: 0xa4b5c0c402797226ba4dadce21117811549de8b62f8acb3065dc49c23965f2a8 +data: [data.fiber.tar.gz](data.fiber.tar.gz) +dev: [dev.toml](dev.toml) +fiber cofig: [fiber.toml](fiber.toml) diff --git a/source/fiber/data.fiber.tar.gz b/source/fiber/data.fiber.tar.gz new file mode 100644 index 0000000..0639a2a Binary files /dev/null and b/source/fiber/data.fiber.tar.gz differ diff --git a/source/fiber/dev.toml b/source/fiber/dev.toml new file mode 100644 index 0000000..f25a259 --- /dev/null +++ b/source/fiber/dev.toml @@ -0,0 +1,100 @@ +name = "ckb_dev" + +[genesis] +version = 0 +parent_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +timestamp = 0 +compact_target = 0x20010000 +uncles_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +nonce = "0x0" + +[genesis.genesis_cell] +message = "1688032132025" + +[genesis.genesis_cell.lock] +code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +args = "0x" +hash_type = "data" + +# An array list paths to system cell files, which is absolute or relative to +# the directory containing this config file. +[[genesis.system_cells]] +file = { bundled = "specs/cells/secp256k1_blake160_sighash_all" } +create_type_id = true +capacity = 100_000_0000_0000 +[[genesis.system_cells]] +file = { bundled = "specs/cells/dao" } +create_type_id = true +capacity = 16_000_0000_0000 +[[genesis.system_cells]] +file = { bundled = "specs/cells/secp256k1_data" } +create_type_id = false +capacity = 1_048_617_0000_0000 +[[genesis.system_cells]] +file = { bundled = "specs/cells/secp256k1_blake160_multisig_all" } +create_type_id = true +capacity = 100_000_0000_0000 + +[genesis.system_cells_lock] +code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +args = "0x" +hash_type = "data" + +# Dep group cells +[[genesis.dep_groups]] +name = "secp256k1_blake160_sighash_all" +files = [ + { bundled = "specs/cells/secp256k1_data" }, + { bundled = "specs/cells/secp256k1_blake160_sighash_all" }, +] +[[genesis.dep_groups]] +name = "secp256k1_blake160_multisig_all" +files = [ + { bundled = "specs/cells/secp256k1_data" }, + { bundled = "specs/cells/secp256k1_blake160_multisig_all" }, +] + +# For first 11 block +[genesis.bootstrap_lock] +code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +args = "0x" +hash_type = "type" + +# Burn +[[genesis.issued_cells]] +capacity = 8_400_000_000_00000000 +lock.code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" +lock.args = "0x62e907b15cbf27d5425399ebf6f0fb50ebb88f18" +lock.hash_type = "data" + +# issue for random generated private key: d00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc +[[genesis.issued_cells]] +capacity = 20_000_000_000_00000000 +lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8" +lock.args = "0xc8328aabcd9b9e8e64fbc566c4385c3bdeb219d7" +lock.hash_type = "type" + +# issue for random generated private key: 63d86723e08f0f813a36ce6aa123bb2289d90680ae1e99d4de8cdb334553f24d +[[genesis.issued_cells]] +capacity = 5_198_735_037_00000000 +lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8" +lock.args = "0x470dcdc5e44064909650113a274b3b36aecb6dc7" +lock.hash_type = "type" + +[params] +initial_primary_epoch_reward = 1_917_808_21917808 +secondary_epoch_reward = 613_698_63013698 +max_block_cycles = 10_000_000_000 +cellbase_maturity = 0 +primary_epoch_reward_halving_interval = 8760 +epoch_duration_target = 14400 +genesis_epoch_length = 1000 +# For development and testing purposes only. +# Keep difficulty be permanent if the pow is Dummy. (default: false) +permanent_difficulty_in_dummy = true + +[params.hardfork] +ckb2023 = 1 + +[pow] +func = "Dummy" diff --git a/source/fiber/dev_config.yml.j2 b/source/fiber/dev_config.yml.j2 new file mode 100644 index 0000000..bf48063 --- /dev/null +++ b/source/fiber/dev_config.yml.j2 @@ -0,0 +1,85 @@ +fiber: + listening_addr: {{ fiber_listening_addr | default("/ip4/127.0.0.1/tcp/8228") }} + chain: dev.toml + announce_listening_addr: true + announce_private_addr: true + gossip_store_maintenance_interval_ms: 1000 + gossip_network_maintenance_interval_ms: 1000 + open_channel_auto_accept_min_ckb_funding_amount: {{ fiber_open_channel_auto_accept_min_ckb_funding_amount | default(10000000000)}} + watchtower_check_interval_seconds: {{ fiber_watchtower_check_interval_seconds | default(60) }} + {% if fiber_disable_built_in_watchtower is defined %} + standalone_watchtower_rpc_url: {{ fiber_standalone_watchtower_rpc_url }} + disable_built_in_watchtower: {{ fiber_disable_built_in_watchtower }} + {% endif %} + {% if fiber_funding_timeout_seconds is defined %} + funding_timeout_seconds: {{ fiber_funding_timeout_seconds }} + {% endif %} + {% if fiber_rpc_biscuit_public_key is defined %} + rpc_biscuit_public_key: {{ fiber_rpc_biscuit_public_key }} + {% endif %} + scripts: + - name: FundingLock + script: + code_hash: 0xd7302abe337c459b84c9da6d739d7736d6e8dbfd2326a509981c35943cfe0f56 + hash_type: type + args: 0x + cell_deps: + - type_id: + code_hash: 0x00000000000000000000000000000000000000000000000000545950455f4944 + hash_type: type + args: 0x52ea1dab3bde46fd55bd352fbf1d5f687d7b02007212a9fc986c5d66763d0ecb + - cell_dep: + out_point: + tx_hash: 0xecb1c1e3df6cd1e1ca16ca9bd392a3c030ece59cb5123bf156c51034e311a3ec # ckb_auth + index: 0x0 + dep_type: code + - name: CommitmentLock + script: + code_hash: 0x2d7d93e3347ddf9f10f6690af75f1e24debaa6c4363f3b2c068f61c757253d38 + hash_type: type + args: 0x + cell_deps: + - type_id: + code_hash: 0x00000000000000000000000000000000000000000000000000545950455f4944 + hash_type: type + args: 0x28da2af59d1949684dc72028cf2c5e979fec6efc954568510f9f62dc9a6415fb + - cell_dep: + out_point: + tx_hash: 0xecb1c1e3df6cd1e1ca16ca9bd392a3c030ece59cb5123bf156c51034e311a3ec #ckb_auth + index: 0x0 + dep_type: code + +rpc: + listening_addr: {{ rpc_listening_addr | default("127.0.0.1:8227") }} + enabled_modules: + - cch + - channel + - payment + - graph + - info + - invoice + - peer + - dev + - watchtower +ckb: + rpc_url: {{ ckb_rpc_url | default("http://127.0.0.1:8114") }} + {% if ckb_udt_whitelist is defined %} + udt_whitelist: + - name: XUDT + + script: + code_hash: 0x102583443ba6cfe5a3ac268bbb4475fb63eb497dce077f126ad3b148d4f4f8f8 + hash_type: type + args: 0x.* + cell_deps: + - type_id: + code_hash: 0x00000000000000000000000000000000000000000000000000545950455f4944 + hash_type: type + args: 0x910391089634a0d2c716586f03e4c053f06e461c8d75a428ff045006e856a6a6 + auto_accept_amount: {{ fiber_auto_accept_amount | default(1000000000)}} + {% endif %} + +services: + - fiber + - rpc + - ckb diff --git a/source/template/fiber/dev_config_2.yml.j2 b/source/template/fiber/dev_config_2.yml.j2 index 6b1273c..ad5db7f 100644 --- a/source/template/fiber/dev_config_2.yml.j2 +++ b/source/template/fiber/dev_config_2.yml.j2 @@ -8,6 +8,14 @@ fiber: open_channel_auto_accept_min_ckb_funding_amount: {{ fiber_open_channel_auto_accept_min_ckb_funding_amount | default(10000000000)}} watchtower_check_interval_seconds: {{ fiber_watchtower_check_interval_seconds | default(60) }} tlc_expiry_delta: {{ fiber_tlc_expiry_delta | default(86400000) }} + {% if fiber_disable_built_in_watchtower is defined %} + standalone_watchtower_rpc_url: {{ fiber_standalone_watchtower_rpc_url }} + disable_built_in_watchtower: {{ fiber_disable_built_in_watchtower }} + {% endif %} + {% if fiber_funding_timeout_seconds is defined %} + funding_timeout_seconds: {{ fiber_funding_timeout_seconds }} + {% endif %} + rpc: listening_addr: {{ rpc_listening_addr | default("127.0.0.1:8227") }} @@ -20,6 +28,7 @@ rpc: - invoice - peer - dev + - watchtower ckb: rpc_url: {{ ckb_rpc_url | default("http://127.0.0.1:8114") }} {% if ckb_udt_whitelist is defined %} diff --git a/test.sh b/test.sh index d36ab27..3a83ed8 100644 --- a/test.sh +++ b/test.sh @@ -14,14 +14,14 @@ run_test() { echo "$pytest_output" # Check if pytest output contains "failed" - if grep -q " FAILED " <<< "$pytest_output"; then + if grep -q "FAILED test_cases" <<< "$pytest_output"; then # Handle failed test case echo "Test case $1 failed" failed_cases+=" $1" return 1 fi - if grep -q " ERROR " <<< "$pytest_output"; then + if grep -q "ERROR test_cases" <<< "$pytest_output"; then # Handle failed test case echo "Test case $1 error" error_cases+=" $1" diff --git a/test_cases/fiber/BiscuitAuth/README.md b/test_cases/fiber/BiscuitAuth/README.md new file mode 100644 index 0000000..8de59f0 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/README.md @@ -0,0 +1,60 @@ +```angular2html +biscuit keypair + +Generating a new random keypair +Private key: ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 +Public key: ed25519/383faaf0aff783efe70479ff34d645ba0d3d729e541b55b17d6344c551bcb1cd +``` + +```angular2html +biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.channels.permissions.bc +EoEBChcKCGNoYW5uZWxzGAMiCQoHCAASAxiACBIkCAASINsP9Satqa_fFDCKxl97PRNMIwvOJyBQdYnf-y6soZV2GkC_bB7lUjFYkzPhFkuamoTtujZWCDieyC6MFHSqsA6GBOdHLClqrmfj8LLD6-px_Vu7J8rqFzcdiBa6SfvSJmkEIiIKILo1TpIlKgviVKd15vntWCSC68ZrabwnaGktOvkvLP7W% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.node.permissions.bc +EnYKDBgDIggKBggAEgIYGBIkCAASINopyBP0DcRvsBVbVBICipz9TTYnUmsu2QltVG4ygSN1GkBfqunuzx6Hy3hOcondX--S0WFRBEpZ9rJ26R93_FuT3I8nyXjXnevNc4Mm_8XpcdYjYYmSXKsYZyr2XvBmC2YBIiIKINoaQJxg4vW2O077DEp-PFa3BTPlIwwqg6lZkFxduW0g% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.peers.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIABIDGIAIEiQIABIghUAHCKzo9Vcn7TREsZdGs-asA4hIOqu14qqX9jYynNEaQG48wMZ4XSPQShXa8eMILEtreIH9_scnhR8kG6Ob4HmubWw785txv0rUp59C2vq0EBrtRbJSV9elMT7wYwibgwAiIgogbG-4B7sVI8SkQb67go34PR-1uYEP69f8vBVxFyTnVAs=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 with.time.permissions.bc +EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggMeUlQ8KBBoCCAISJAgAEiBhUyrODnAHKwW5mwHsM6ctigIB7Q-7qkGFYYqL-FoZAxpATv2rCmXewLYo_mpIxrlmQpYOK9aY3wHF7TzOA3CcrVdwAYmP1xmcQNVpg4qY8S3ivbKsoCiHHs0pZr0T6iW8DCIiCiDbZdEp2W9T48829r624rZJea29znATjjotAlqvHYWRQA==% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.invoices.permissions.bc +EoEBChcKCGludm9pY2VzGAMiCQoHCAESAxiACBIkCAASIGP1E2XvPIjo7-ZWUcsxBbY9A41jMCHg1YXGn7gUpLJBGkDZnhe48CRog6UYrxTe1HXF0PQPQsSzkcRYrjzxIACRdWyIFn3htiVWquT_LETdb99zyPkOih53kS7_M-N2AJkEIiIKIJMbRnk0SEzafTZE145UXf47lpfGxaQ0zIMS4Qg0Z1uc% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.peers.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIARIDGIAIEiQIABIgsCUDMwC8_udzem5EBgANEylv8BzEiuVCh_73dmkPETgaQIZJXHL5Wr0XtTo2-DCVubDfK8Am375EodtyDY_6avWowuxLkV8l5nWwmVLn1NWy6504t3-j8pUClwHL8C8row8iIgog46JbovXKs52uX1R_DE3nwmoWsEbVXeYuwrPbZpfpAjs=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.graph.permissions.bc +En4KFAoFZ3JhcGgYAyIJCgcIABIDGIAIEiQIABIg_WPX5JWXGjmDXXr4kdX8WuNPOPp6yFTowiwci-FfoNsaQE2ceC8fXdXjZNAl84nnxIT23qxnZrt7eRPCRU7M4nWzF-jd6nQrht5-n5BARiP9bO7ojTZTGN_m7aVqvJvdxAsiIgogmmuIrTzzW96h9mGwiDLvYkdHf0QOVwySjSslgRX7j1Q=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.payments.permissions.bc +EoEBChcKCHBheW1lbnRzGAMiCQoHCAASAxiACBIkCAASIGYsRFFn589TOs6VHuZ6-BSGLTuJCsKVaJQlZGWgqtviGkCe21ZH7UsOAmlxmfffNWq7z7Jwl5EruNrGs1SWew8UJesZQhDsKh2Ady7gDtMoND4gEODraec1T76bvLHcGl8KIiIKIClDc2CoQYflPtisdyVLUUS6e1CWaharIj_DCwzwK86M% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 rpc.permissions.bc +EsQCCtkBCghjaGFubmVscwoIbWVzc2FnZXMKBWNoYWluCgVncmFwaAoIaW52b2ljZXMKCHBheW1lbnRzCgVwZWVycwoKd2F0Y2h0b3dlchgDIgkKBwgBEgMYgAgiCQoHCAASAxiACCIJCgcIARIDGIEIIgkKBwgBEgMYgggiCQoHCAASAxiDCCIICgYIABICGBgiCQoHCAESAxiECCIJCgcIABIDGIQIIgkKBwgBEgMYhQgiCQoHCAASAxiFCCIJCgcIARIDGIYIIgkKBwgAEgMYhggiCQoHCAESAxiHCBIkCAASILebWZiVMVNRSxMq-CED9Y0GCKe7VMoYKjBhWKmJTg8sGkCyUmmbk7SA-fsbwQdDvA3hAhC86lT3KmoyP5hQvaTNS2PrzTrcoV4u2M1LqCBtoVFqrE7kMB9D5nfo_A2S6fYAIiIKIEw4XnRlMyolWgVi_b56CCU7y4_vNhF4CP8uolIx58TV% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.chain.permissions.bc +En4KFAoFY2hhaW4YAyIJCgcIARIDGIAIEiQIABIgK8pWKnqb6Tc-1yxY7KTwku2pUSybK57p66xYxVH0v34aQIJn8JuYs8bMTJU2jScLc_eRb4RURq9fKjHc8oqHiPvV4AG6k7_Eu_w8MeOZhBDALSEQd9RYxNNY8-MMRBqGRwsiIgogFizTMLygvkIL3k_pOYjqjY9YKOMYWvVioXQAArqO8ds=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.message.permissions.bc +EoEBChcKCG1lc3NhZ2VzGAMiCQoHCAESAxiACBIkCAASIH_QlrvivLt1ON8ALvSv_LW0wAC9R11whTQ88QjXblxdGkBRMvAjmzsPeQK8RT3wLC3-GjjidHi_Poh4gEEN4DvEfUBZ3dgUXE8lVRlPJsZPWLP-45HLcwXlHtv1iA1X12QEIiIKIKYquYDxsVe2TF3XS98HagDBzh4znzpm9bV700bizzbc% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.watchtower.permissions.bc +EoMBChkKCndhdGNodG93ZXIYAyIJCgcIARIDGIAIEiQIABIgO3N9hDIGRelKRiR_cmFvTJLbZxzJPKATQkiDV4sot8waQNenFDsHMkjqjeLRmZToXBLkmWN5AH6GuqMkJrOlO_Z1CqjGNRWaDer7bJiBnvgM5hXKJxa6iCSNAwYq37J8oAkiIgog_QaTJZbuJRTzwZMK9ebWqPBI6tF9LfEKaI32bRUK3o8=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.invoices.permissions.bc +EoEBChcKCGludm9pY2VzGAMiCQoHCAASAxiACBIkCAASICVntbqaMdAoL0RnPlYa9hZIKSHteY35WPq7rZeAqIiOGkBdpL3n1zj8vLXOgx_aj6y8x9QrNpXWhzEn3ZlG8CpfEl-5g9gr8FQkHR0vu2q2Db08TNeuC2_F6v3PS9n2qUEIIiIKIOn-geVslpAMBl3-9FjGnM66LS-FVDKAy1j80KMDQ3Yw% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.peer.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIABIDGIAIEiQIABIg83zznPCI7oR4mAPaaARcdmqeSCsj7tvk6rn8J-qQEW4aQKfXZZmBO5q2w7oyN1mWUrrJdn4ZVXhEsCFXmRiOytJAv0JXK9_SQEI50cCo3duUB0hCKsZGzHScyB5f6HziWQMiIgogwyXOIe4t6U6gZV9eDfeAP6JUK_AP_6wnnVXg3IiP93g=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 timeout.permissions.bc +EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggIvSuwYKBBoCCAISJAgAEiBJiOUmeIhW0F7iTkOokRAwA-DWGOA3LXpwleiPhO_7fBpAzueSyOOLnmBll1iGeX5GIjS3IiRLBQ4VTGqN2P9vc7B_Fkg-thsrBROWngupphmN5IalwhpDi2APL-6t97bmACIiCiD4zzBy5woFGESdj2iO2918lgjf2IM6Dal-JWe1VYr3ng==% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.channels.permissions.bc +EoEBChcKCGNoYW5uZWxzGAMiCQoHCAESAxiACBIkCAASIAniDe3GeZnq6wHsXnazEucFmdbTFGRcHXfW8AoBwh_XGkAEqzz0DA7rzh3VIiimIMXK4Z-CaGCECT2eNel9z8MZ116ylc8yHMxD8vHFFiOeA2l92A1gQds43dyz11dZa0QBIiIKIBYcyHeA6CxHsdRsX3kbOlcAFirp_1gUSPJVvsB5ofXL% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.payments.permissions.bc +EoEBChcKCHBheW1lbnRzGAMiCQoHCAESAxiACBIkCAASIM9orpucr8t8L1Qlv28OejTiNo1ws9vlxwzdk9gZEhjVGkDGd4A3W5WmHJB9IRiV3UROgPE4eL_F2UzOuJdHOiRPwjdxsdSOQYB00oWeHW70K7knKCEC8pG2Z4dIklgHFTAAIiIKILKXG0X7AtjjwXkBYdcBlbRtXwhiezIvMkkFWvFrbpSh% +``` \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.channels.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.channels.permissions.bc new file mode 100644 index 0000000..fecd925 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.channels.permissions.bc @@ -0,0 +1 @@ +read("channels"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.graph.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.graph.permissions.bc new file mode 100644 index 0000000..298fb86 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.graph.permissions.bc @@ -0,0 +1 @@ +read("graph"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.invoices.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.invoices.permissions.bc new file mode 100644 index 0000000..b3fb551 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.invoices.permissions.bc @@ -0,0 +1 @@ +read("invoices"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.node.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.node.permissions.bc new file mode 100644 index 0000000..d6d23a8 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.node.permissions.bc @@ -0,0 +1 @@ +read("node"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.payments.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.payments.permissions.bc new file mode 100644 index 0000000..6b7a5dd --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.payments.permissions.bc @@ -0,0 +1 @@ +read("payments"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.peer.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.peer.permissions.bc new file mode 100644 index 0000000..3117793 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.peer.permissions.bc @@ -0,0 +1 @@ +read("peers"); diff --git a/test_cases/fiber/BiscuitAuth/permissions/read.peers.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/read.peers.permissions.bc new file mode 100644 index 0000000..1a3edc9 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/read.peers.permissions.bc @@ -0,0 +1 @@ +read("peers"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/rpc.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/rpc.permissions.bc new file mode 100644 index 0000000..9b6b0af --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/rpc.permissions.bc @@ -0,0 +1,13 @@ +write("channels"); +read("channels"); +write("messages"); +write("chain"); +read("graph"); +read("node"); +write("invoices"); +read("invoices"); +write("payments"); +read("payments"); +write("peers"); +read("peers"); +write("watchtower"); diff --git a/test_cases/fiber/BiscuitAuth/permissions/timeout.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/timeout.permissions.bc new file mode 100644 index 0000000..850820e --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/timeout.permissions.bc @@ -0,0 +1,2 @@ +read("peers"); +check if time($time), $time <= 2025-01-01T00:00:00Z; diff --git a/test_cases/fiber/BiscuitAuth/permissions/with.time.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/with.time.permissions.bc new file mode 100644 index 0000000..c33286c --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/with.time.permissions.bc @@ -0,0 +1,2 @@ +read("peers"); +check if time($time), $time <= 2099-01-01T00:00:00Z; diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.chain.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.chain.permissions.bc new file mode 100644 index 0000000..ff82098 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.chain.permissions.bc @@ -0,0 +1 @@ +write("chain") \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.channels.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.channels.permissions.bc new file mode 100644 index 0000000..d5edcc3 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.channels.permissions.bc @@ -0,0 +1 @@ +write("channels") \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.invoices.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.invoices.permissions.bc new file mode 100644 index 0000000..699bcb7 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.invoices.permissions.bc @@ -0,0 +1 @@ +write("invoices"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.message.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.message.permissions.bc new file mode 100644 index 0000000..496ab98 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.message.permissions.bc @@ -0,0 +1 @@ +write("messages") \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.payments.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.payments.permissions.bc new file mode 100644 index 0000000..124e6d5 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.payments.permissions.bc @@ -0,0 +1 @@ +write("payments") \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.peers.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.peers.permissions.bc new file mode 100644 index 0000000..df5d30a --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.peers.permissions.bc @@ -0,0 +1 @@ +write("peers"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/permissions/write.watchtower.permissions.bc b/test_cases/fiber/BiscuitAuth/permissions/write.watchtower.permissions.bc new file mode 100644 index 0000000..bf6de74 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/permissions/write.watchtower.permissions.bc @@ -0,0 +1 @@ +write("watchtower"); \ No newline at end of file diff --git a/test_cases/fiber/BiscuitAuth/test_auth.py b/test_cases/fiber/BiscuitAuth/test_auth.py new file mode 100644 index 0000000..bb8a2a4 --- /dev/null +++ b/test_cases/fiber/BiscuitAuth/test_auth.py @@ -0,0 +1,384 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest +from framework.fiber_rpc import FiberRPCClient + +""" +biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.channels.permissions.bc +EoEBChcKCGNoYW5uZWxzGAMiCQoHCAASAxiACBIkCAASINsP9Satqa_fFDCKxl97PRNMIwvOJyBQdYnf-y6soZV2GkC_bB7lUjFYkzPhFkuamoTtujZWCDieyC6MFHSqsA6GBOdHLClqrmfj8LLD6-px_Vu7J8rqFzcdiBa6SfvSJmkEIiIKILo1TpIlKgviVKd15vntWCSC68ZrabwnaGktOvkvLP7W% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.node.permissions.bc +EnYKDBgDIggKBggAEgIYGBIkCAASINopyBP0DcRvsBVbVBICipz9TTYnUmsu2QltVG4ygSN1GkBfqunuzx6Hy3hOcondX--S0WFRBEpZ9rJ26R93_FuT3I8nyXjXnevNc4Mm_8XpcdYjYYmSXKsYZyr2XvBmC2YBIiIKINoaQJxg4vW2O077DEp-PFa3BTPlIwwqg6lZkFxduW0g% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.peers.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIABIDGIAIEiQIABIghUAHCKzo9Vcn7TREsZdGs-asA4hIOqu14qqX9jYynNEaQG48wMZ4XSPQShXa8eMILEtreIH9_scnhR8kG6Ob4HmubWw785txv0rUp59C2vq0EBrtRbJSV9elMT7wYwibgwAiIgogbG-4B7sVI8SkQb67go34PR-1uYEP69f8vBVxFyTnVAs=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 with.time.permissions.bc +EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggMeUlQ8KBBoCCAISJAgAEiBhUyrODnAHKwW5mwHsM6ctigIB7Q-7qkGFYYqL-FoZAxpATv2rCmXewLYo_mpIxrlmQpYOK9aY3wHF7TzOA3CcrVdwAYmP1xmcQNVpg4qY8S3ivbKsoCiHHs0pZr0T6iW8DCIiCiDbZdEp2W9T48829r624rZJea29znATjjotAlqvHYWRQA==% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.invoices.permissions.bc +EoEBChcKCGludm9pY2VzGAMiCQoHCAESAxiACBIkCAASIGP1E2XvPIjo7-ZWUcsxBbY9A41jMCHg1YXGn7gUpLJBGkDZnhe48CRog6UYrxTe1HXF0PQPQsSzkcRYrjzxIACRdWyIFn3htiVWquT_LETdb99zyPkOih53kS7_M-N2AJkEIiIKIJMbRnk0SEzafTZE145UXf47lpfGxaQ0zIMS4Qg0Z1uc% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.peers.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIARIDGIAIEiQIABIgsCUDMwC8_udzem5EBgANEylv8BzEiuVCh_73dmkPETgaQIZJXHL5Wr0XtTo2-DCVubDfK8Am375EodtyDY_6avWowuxLkV8l5nWwmVLn1NWy6504t3-j8pUClwHL8C8row8iIgog46JbovXKs52uX1R_DE3nwmoWsEbVXeYuwrPbZpfpAjs=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.graph.permissions.bc +En4KFAoFZ3JhcGgYAyIJCgcIABIDGIAIEiQIABIg_WPX5JWXGjmDXXr4kdX8WuNPOPp6yFTowiwci-FfoNsaQE2ceC8fXdXjZNAl84nnxIT23qxnZrt7eRPCRU7M4nWzF-jd6nQrht5-n5BARiP9bO7ojTZTGN_m7aVqvJvdxAsiIgogmmuIrTzzW96h9mGwiDLvYkdHf0QOVwySjSslgRX7j1Q= + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.payments.permissions.bc +EoEBChcKCHBheW1lbnRzGAMiCQoHCAASAxiACBIkCAASIGYsRFFn589TOs6VHuZ6-BSGLTuJCsKVaJQlZGWgqtviGkCe21ZH7UsOAmlxmfffNWq7z7Jwl5EruNrGs1SWew8UJesZQhDsKh2Ady7gDtMoND4gEODraec1T76bvLHcGl8KIiIKIClDc2CoQYflPtisdyVLUUS6e1CWaharIj_DCwzwK86M% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 rpc.permissions.bc +EsQCCtkBCghjaGFubmVscwoIbWVzc2FnZXMKBWNoYWluCgVncmFwaAoIaW52b2ljZXMKCHBheW1lbnRzCgVwZWVycwoKd2F0Y2h0b3dlchgDIgkKBwgBEgMYgAgiCQoHCAASAxiACCIJCgcIARIDGIEIIgkKBwgBEgMYgggiCQoHCAASAxiDCCIICgYIABICGBgiCQoHCAESAxiECCIJCgcIABIDGIQIIgkKBwgBEgMYhQgiCQoHCAASAxiFCCIJCgcIARIDGIYIIgkKBwgAEgMYhggiCQoHCAESAxiHCBIkCAASILebWZiVMVNRSxMq-CED9Y0GCKe7VMoYKjBhWKmJTg8sGkCyUmmbk7SA-fsbwQdDvA3hAhC86lT3KmoyP5hQvaTNS2PrzTrcoV4u2M1LqCBtoVFqrE7kMB9D5nfo_A2S6fYAIiIKIEw4XnRlMyolWgVi_b56CCU7y4_vNhF4CP8uolIx58TV% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.chain.permissions.bc +En4KFAoFY2hhaW4YAyIJCgcIARIDGIAIEiQIABIgK8pWKnqb6Tc-1yxY7KTwku2pUSybK57p66xYxVH0v34aQIJn8JuYs8bMTJU2jScLc_eRb4RURq9fKjHc8oqHiPvV4AG6k7_Eu_w8MeOZhBDALSEQd9RYxNNY8-MMRBqGRwsiIgogFizTMLygvkIL3k_pOYjqjY9YKOMYWvVioXQAArqO8ds=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.message.permissions.bc +EoEBChcKCG1lc3NhZ2VzGAMiCQoHCAESAxiACBIkCAASIH_QlrvivLt1ON8ALvSv_LW0wAC9R11whTQ88QjXblxdGkBRMvAjmzsPeQK8RT3wLC3-GjjidHi_Poh4gEEN4DvEfUBZ3dgUXE8lVRlPJsZPWLP-45HLcwXlHtv1iA1X12QEIiIKIKYquYDxsVe2TF3XS98HagDBzh4znzpm9bV700bizzbc% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.watchtower.permissions.bc +EoMBChkKCndhdGNodG93ZXIYAyIJCgcIARIDGIAIEiQIABIgO3N9hDIGRelKRiR_cmFvTJLbZxzJPKATQkiDV4sot8waQNenFDsHMkjqjeLRmZToXBLkmWN5AH6GuqMkJrOlO_Z1CqjGNRWaDer7bJiBnvgM5hXKJxa6iCSNAwYq37J8oAkiIgog_QaTJZbuJRTzwZMK9ebWqPBI6tF9LfEKaI32bRUK3o8=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.invoices.permissions.bc +EoEBChcKCGludm9pY2VzGAMiCQoHCAASAxiACBIkCAASICVntbqaMdAoL0RnPlYa9hZIKSHteY35WPq7rZeAqIiOGkBdpL3n1zj8vLXOgx_aj6y8x9QrNpXWhzEn3ZlG8CpfEl-5g9gr8FQkHR0vu2q2Db08TNeuC2_F6v3PS9n2qUEIIiIKIOn-geVslpAMBl3-9FjGnM66LS-FVDKAy1j80KMDQ3Yw% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 read.peer.permissions.bc +En4KFAoFcGVlcnMYAyIJCgcIABIDGIAIEiQIABIg83zznPCI7oR4mAPaaARcdmqeSCsj7tvk6rn8J-qQEW4aQKfXZZmBO5q2w7oyN1mWUrrJdn4ZVXhEsCFXmRiOytJAv0JXK9_SQEI50cCo3duUB0hCKsZGzHScyB5f6HziWQMiIgogwyXOIe4t6U6gZV9eDfeAP6JUK_AP_6wnnVXg3IiP93g=% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 timeout.permissions.bc +EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggIvSuwYKBBoCCAISJAgAEiBJiOUmeIhW0F7iTkOokRAwA-DWGOA3LXpwleiPhO_7fBpAzueSyOOLnmBll1iGeX5GIjS3IiRLBQ4VTGqN2P9vc7B_Fkg-thsrBROWngupphmN5IalwhpDi2APL-6t97bmACIiCiD4zzBy5woFGESdj2iO2918lgjf2IM6Dal-JWe1VYr3ng==% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.channels.permissions.bc +EoEBChcKCGNoYW5uZWxzGAMiCQoHCAESAxiACBIkCAASIAniDe3GeZnq6wHsXnazEucFmdbTFGRcHXfW8AoBwh_XGkAEqzz0DA7rzh3VIiimIMXK4Z-CaGCECT2eNel9z8MZ116ylc8yHMxD8vHFFiOeA2l92A1gQds43dyz11dZa0QBIiIKIBYcyHeA6CxHsdRsX3kbOlcAFirp_1gUSPJVvsB5ofXL% + +guopenglin@MacBook-Pro-4 permissions % biscuit generate --private-key ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535 write.payments.permissions.bc +EoEBChcKCHBheW1lbnRzGAMiCQoHCAESAxiACBIkCAASIM9orpucr8t8L1Qlv28OejTiNo1ws9vlxwzdk9gZEhjVGkDGd4A3W5WmHJB9IRiV3UROgPE4eL_F2UzOuJdHOiRPwjdxsdSOQYB00oWeHW70K7knKCEC8pG2Z4dIklgHFTAAIiIKILKXG0X7AtjjwXkBYdcBlbRtXwhiezIvMkkFWvFrbpSh% +""" + + +class TestAuth(FiberTest): + + def test_demo(self): + self.fiber1.stop() + self.fiber1.start( + rpc_biscuit_public_key="ed25519-private/f02ac69460ca158e88d5728cb8ae26aab9aa172f3db4e95ed6e9f729e2212535" + ) + # # todo asser start failed + # run_command("lsof -i:8228", False) + # # 符合规范的id :ed25519/xxxx + time.sleep(1) + self.fiber1.start( + rpc_biscuit_public_key="ed25519/383faaf0aff783efe70479ff34d645ba0d3d729e541b55b17d6344c551bcb1cd" + ) + time.sleep(3) + # read.channels.permissions.bc + readChannelsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCGNoYW5uZWxzGAMiCQoHCAASAxiACBIkCAASINsP9Satqa_fFDCKxl97PRNMIwvOJyBQdYnf-y6soZV2GkC_bB7lUjFYkzPhFkuamoTtujZWCDieyC6MFHSqsA6GBOdHLClqrmfj8LLD6-px_Vu7J8rqFzcdiBa6SfvSJmkEIiIKILo1TpIlKgviVKd15vntWCSC68ZrabwnaGktOvkvLP7W" + }, + 1, + ) + # read.graph.permissions.bc + readGraphFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer En4KFAoFZ3JhcGgYAyIJCgcIABIDGIAIEiQIABIg_WPX5JWXGjmDXXr4kdX8WuNPOPp6yFTowiwci-FfoNsaQE2ceC8fXdXjZNAl84nnxIT23qxnZrt7eRPCRU7M4nWzF-jd6nQrht5-n5BARiP9bO7ojTZTGN_m7aVqvJvdxAsiIgogmmuIrTzzW96h9mGwiDLvYkdHf0QOVwySjSslgRX7j1Q=" + }, + 1, + ) + # read.invoices.permissions.bc + readInvoicesFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCGludm9pY2VzGAMiCQoHCAASAxiACBIkCAASICVntbqaMdAoL0RnPlYa9hZIKSHteY35WPq7rZeAqIiOGkBdpL3n1zj8vLXOgx_aj6y8x9QrNpXWhzEn3ZlG8CpfEl-5g9gr8FQkHR0vu2q2Db08TNeuC2_F6v3PS9n2qUEIIiIKIOn-geVslpAMBl3-9FjGnM66LS-FVDKAy1j80KMDQ3Yw" + }, + 1, + ) + # read.node.permissions.bc + readNodeFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EnYKDBgDIggKBggAEgIYGBIkCAASINopyBP0DcRvsBVbVBICipz9TTYnUmsu2QltVG4ygSN1GkBfqunuzx6Hy3hOcondX--S0WFRBEpZ9rJ26R93_FuT3I8nyXjXnevNc4Mm_8XpcdYjYYmSXKsYZyr2XvBmC2YBIiIKINoaQJxg4vW2O077DEp-PFa3BTPlIwwqg6lZkFxduW0g" + }, + 1, + ) + # read.payments.permissions.bc + readPaymentsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCHBheW1lbnRzGAMiCQoHCAASAxiACBIkCAASIGYsRFFn589TOs6VHuZ6-BSGLTuJCsKVaJQlZGWgqtviGkCe21ZH7UsOAmlxmfffNWq7z7Jwl5EruNrGs1SWew8UJesZQhDsKh2Ady7gDtMoND4gEODraec1T76bvLHcGl8KIiIKIClDc2CoQYflPtisdyVLUUS6e1CWaharIj_DCwzwK86M" + }, + 1, + ) + # read.peer.permissions.bc + readPeersPermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer En4KFAoFcGVlcnMYAyIJCgcIABIDGIAIEiQIABIg83zznPCI7oR4mAPaaARcdmqeSCsj7tvk6rn8J-qQEW4aQKfXZZmBO5q2w7oyN1mWUrrJdn4ZVXhEsCFXmRiOytJAv0JXK9_SQEI50cCo3duUB0hCKsZGzHScyB5f6HziWQMiIgogwyXOIe4t6U6gZV9eDfeAP6JUK_AP_6wnnVXg3IiP93g=" + }, + 1, + ) + # read.peers.permissions.bc + # rpc.permissions.bc + rpcPermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EsQCCtkBCghjaGFubmVscwoIbWVzc2FnZXMKBWNoYWluCgVncmFwaAoIaW52b2ljZXMKCHBheW1lbnRzCgVwZWVycwoKd2F0Y2h0b3dlchgDIgkKBwgBEgMYgAgiCQoHCAASAxiACCIJCgcIARIDGIEIIgkKBwgBEgMYgggiCQoHCAASAxiDCCIICgYIABICGBgiCQoHCAESAxiECCIJCgcIABIDGIQIIgkKBwgBEgMYhQgiCQoHCAASAxiFCCIJCgcIARIDGIYIIgkKBwgAEgMYhggiCQoHCAESAxiHCBIkCAASILebWZiVMVNRSxMq-CED9Y0GCKe7VMoYKjBhWKmJTg8sGkCyUmmbk7SA-fsbwQdDvA3hAhC86lT3KmoyP5hQvaTNS2PrzTrcoV4u2M1LqCBtoVFqrE7kMB9D5nfo_A2S6fYAIiIKIEw4XnRlMyolWgVi_b56CCU7y4_vNhF4CP8uolIx58TV" + }, + 1, + ) + # timeout.permissions.bc + timeoutPermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggIvSuwYKBBoCCAISJAgAEiBJiOUmeIhW0F7iTkOokRAwA-DWGOA3LXpwleiPhO_7fBpAzueSyOOLnmBll1iGeX5GIjS3IiRLBQ4VTGqN2P9vc7B_Fkg-thsrBROWngupphmN5IalwhpDi2APL-6t97bmACIiCiD4zzBy5woFGESdj2iO2918lgjf2IM6Dal-JWe1VYr3ng==" + }, + 1, + ) + # with.time.permissions.bc + withTimePermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EqYBCjwKBXBlZXJzGAMiCQoHCAASAxiACDImCiQKAggbEgYIBRICCAUaFgoECgIIBQoICgYggMeUlQ8KBBoCCAISJAgAEiBhUyrODnAHKwW5mwHsM6ctigIB7Q-7qkGFYYqL-FoZAxpATv2rCmXewLYo_mpIxrlmQpYOK9aY3wHF7TzOA3CcrVdwAYmP1xmcQNVpg4qY8S3ivbKsoCiHHs0pZr0T6iW8DCIiCiDbZdEp2W9T48829r624rZJea29znATjjotAlqvHYWRQA==" + }, + 1, + ) + # write.chain.permissions.bc + writeChainPermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer En4KFAoFY2hhaW4YAyIJCgcIARIDGIAIEiQIABIgK8pWKnqb6Tc-1yxY7KTwku2pUSybK57p66xYxVH0v34aQIJn8JuYs8bMTJU2jScLc_eRb4RURq9fKjHc8oqHiPvV4AG6k7_Eu_w8MeOZhBDALSEQd9RYxNNY8-MMRBqGRwsiIgogFizTMLygvkIL3k_pOYjqjY9YKOMYWvVioXQAArqO8ds=" + }, + 1, + ) + # write.channels.permissions.bc + writeChannelsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCGNoYW5uZWxzGAMiCQoHCAESAxiACBIkCAASIAniDe3GeZnq6wHsXnazEucFmdbTFGRcHXfW8AoBwh_XGkAEqzz0DA7rzh3VIiimIMXK4Z-CaGCECT2eNel9z8MZ116ylc8yHMxD8vHFFiOeA2l92A1gQds43dyz11dZa0QBIiIKIBYcyHeA6CxHsdRsX3kbOlcAFirp_1gUSPJVvsB5ofXL" + }, + 1, + ) + # write.invoices.permissions.bc + writeInvoicesFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCGludm9pY2VzGAMiCQoHCAESAxiACBIkCAASIGP1E2XvPIjo7-ZWUcsxBbY9A41jMCHg1YXGn7gUpLJBGkDZnhe48CRog6UYrxTe1HXF0PQPQsSzkcRYrjzxIACRdWyIFn3htiVWquT_LETdb99zyPkOih53kS7_M-N2AJkEIiIKIJMbRnk0SEzafTZE145UXf47lpfGxaQ0zIMS4Qg0Z1uc" + }, + 1, + ) + # write.message.permissions.bc + writeMessageFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCG1lc3NhZ2VzGAMiCQoHCAESAxiACBIkCAASIH_QlrvivLt1ON8ALvSv_LW0wAC9R11whTQ88QjXblxdGkBRMvAjmzsPeQK8RT3wLC3-GjjidHi_Poh4gEEN4DvEfUBZ3dgUXE8lVRlPJsZPWLP-45HLcwXlHtv1iA1X12QEIiIKIKYquYDxsVe2TF3XS98HagDBzh4znzpm9bV700bizzbc" + }, + 1, + ) + # write.payments.permissions.bc + writePaymentsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoEBChcKCHBheW1lbnRzGAMiCQoHCAESAxiACBIkCAASIM9orpucr8t8L1Qlv28OejTiNo1ws9vlxwzdk9gZEhjVGkDGd4A3W5WmHJB9IRiV3UROgPE4eL_F2UzOuJdHOiRPwjdxsdSOQYB00oWeHW70K7knKCEC8pG2Z4dIklgHFTAAIiIKILKXG0X7AtjjwXkBYdcBlbRtXwhiezIvMkkFWvFrbpSh" + }, + 1, + ) + # write.peers.permissions.bc + writePeersPermissionsFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer En4KFAoFcGVlcnMYAyIJCgcIARIDGIAIEiQIABIgsCUDMwC8_udzem5EBgANEylv8BzEiuVCh_73dmkPETgaQIZJXHL5Wr0XtTo2-DCVubDfK8Am375EodtyDY_6avWowuxLkV8l5nWwmVLn1NWy6504t3-j8pUClwHL8C8row8iIgog46JbovXKs52uX1R_DE3nwmoWsEbVXeYuwrPbZpfpAjs=" + }, + 1, + ) + # write.watchtower.permissions.bc + writeWatchtowerFiberClient = FiberRPCClient( + self.fiber1.get_client().url, + { + "Authorization": "Bearer EoMBChkKCndhdGNodG93ZXIYAyIJCgcIARIDGIAIEiQIABIgO3N9hDIGRelKRiR_cmFvTJLbZxzJPKATQkiDV4sot8waQNenFDsHMkjqjeLRmZToXBLkmWN5AH6GuqMkJrOlO_Z1CqjGNRWaDer7bJiBnvgM5hXKJxa6iCSNAwYq37J8oAkiIgog_QaTJZbuJRTzwZMK9ebWqPBI6tF9LfEKaI32bRUK3o8=" + }, + 1, + ) + + # write("channels") + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.open_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + with pytest.raises(Exception) as exc_info: + rpcPermissionsFiberClient.open_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.accept_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.abandon_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.shutdown_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.update_channel({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + # todo add_tlc + # todo remove_tlc + + with pytest.raises(Exception) as exc_info: + writeChannelsFiberClient.list_channels({}) + expected_error_message = "Unauthorized" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + # read("channels"); + list_channels = readChannelsFiberClient.list_channels({}) + assert list_channels["channels"] == [] + rpc_list_channels = rpcPermissionsFiberClient.list_channels({}) + assert rpc_list_channels["channels"] == [] + + with pytest.raises(Exception) as exc_info: + readChannelsFiberClient.open_channel({}) + expected_error_message = "Unauthorized" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + # todo write("messages") + # commitment_signed + # todo write("chain") + # submit_commitment_transaction + # read("graph"); + + # graph_nodes + nodes = readGraphFiberClient.graph_nodes({}) + assert len(nodes["nodes"]) == 2 + nodes = rpcPermissionsFiberClient.graph_nodes({}) + assert len(nodes["nodes"]) == 2 + + # graph_channels + channels = readGraphFiberClient.graph_channels({}) + assert channels["channels"] == [] + + # read("node"); + # node_info + node_info = readNodeFiberClient.node_info() + assert node_info["tlc_min_value"] == "0x0" + # write("invoices"); + # new_invoice + invoice = writeInvoicesFiberClient.new_invoice( + { + "amount": hex(1), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + } + ) + # cancel_invoice + writeInvoicesFiberClient.cancel_invoice( + {"payment_hash": invoice["invoice"]["data"]["payment_hash"]} + ) + # read("invoices"); + # parse_invoice + readInvoicesFiberClient.parse_invoice({"invoice": invoice["invoice_address"]}) + # get_invoice + invoice = readInvoicesFiberClient.get_invoice( + {"payment_hash": invoice["invoice"]["data"]["payment_hash"]} + ) + assert invoice["status"] == "Cancelled" + # write("payments") + # send_payment + with pytest.raises(Exception) as exc_info: + writePaymentsFiberClient.send_payment({}) + expected_error_message = "Failed to validate payment request" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + # send_payment_with_router + with pytest.raises(Exception) as exc_info: + writePaymentsFiberClient.send_payment_with_router({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + # read("payments"); + # get_payment + with pytest.raises(Exception) as exc_info: + readPaymentsFiberClient.get_payment({}) + expected_error_message = "Invalid param" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + # write("peers"); + # connect_peer + writePeersPermissionsFiberClient.connect_peer( + {"address": self.fiber2.get_client().node_info()["addresses"][0]} + ) + # disconnect_peer + writePeersPermissionsFiberClient.disconnect_peer( + {"peer_id": self.fiber2.get_peer_id()} + ) + # read("peers") + # list_peers + peers = readPeersPermissionsFiberClient.list_peers() + assert peers["peers"] == [] + # todo write("watchtower"); + # create_watch_channel + # remove_watch_channel + # update_revocation + # update_local_settlement + # create_preimage + # remove_preimage + # todo right({channel_id}, "watchtower") + # create_watch_channel + + # - 限时 + # - $time 限制token有效期 + with pytest.raises(Exception) as exc_info: + timeoutPermissionsFiberClient.list_peers() + expected_error_message = "Unauthorized" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + peers = withTimePermissionsFiberClient.list_peers() + readPeers = readPeersPermissionsFiberClient.list_peers() + assert peers["peers"] == readPeers["peers"] diff --git a/test_cases/fiber/config/test_standalone_watchtower_rpc_url.py b/test_cases/fiber/config/test_standalone_watchtower_rpc_url.py new file mode 100644 index 0000000..7270d4d --- /dev/null +++ b/test_cases/fiber/config/test_standalone_watchtower_rpc_url.py @@ -0,0 +1,323 @@ +""" +standalone_watchtower_rpc_url +disable_built_in_watchtower +""" + +import shutil +import time + +import pytest + +from framework.basic_fiber import FiberTest + + +class TestWatchTower(FiberTest): + # debug = True + start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} + + def test_old_force_shutdown_channel(self): + """ + 之前有channel，然后监听 + channel ready 的channel，瞭望塔无法工作 + Returns: + + """ + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.send_payment(self.fiber1, self.fiber2, 1) + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx) + self.fiber1.stop() + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": True, + } + ) + self.fiber2.start() + time.sleep(5) + self.node.getClient().generate_epochs("0x1", 0) + with pytest.raises(Exception) as exc_info: + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + expected_error_message = "expected_state" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.fiber1.start() + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + + def test_old_channel(self): + """ + 之前有channel，然后监听 + channel ready 的channel，瞭望塔无法工作 + Returns: + + """ + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": True, + } + ) + self.fiber2.start() + time.sleep(5) + self.send_payment(self.fiber1, self.fiber2, 1) + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx) + self.fiber1.stop() + self.node.getClient().generate_epochs("0x1", 0) + with pytest.raises(Exception) as exc_info: + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + expected_error_message = "expected_state" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.fiber1.start() + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + + def test_no_balance(self): + """ + standalone_watchtower_rpc 没有ckb + 监听到watchtower 交易，报：Failed to build settlement tx: Other(Not enough capacity)，充值后正常发送shutdown交易 + Returns: + """ + self.fiber3 = self.start_new_fiber(self.generate_random_preimage()) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": "true", + } + ) + self.fiber2.start() + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx) + self.fiber1.stop() + self.node.getClient().generate_epochs("0x1", 0) + with pytest.raises(Exception) as exc_info: + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + expected_error_message = "expected_state" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.faucet(self.fiber3.account_private, 1000) + tx = self.wait_and_check_tx_pool_fee(1000, False, 20 * 5) + self.Miner.miner_until_tx_committed(self.node, tx) + msg = self.get_tx_message(tx) + print("force shutdown tx:", msg) + assert { + "args": self.fiber2.get_account()["lock_arg"], + "capacity": 6199999546, + } in msg["output_cells"] + assert { + "args": self.fiber1.get_account()["lock_arg"], + "capacity": 106199999545, + } in msg["output_cells"] + assert { + "args": self.fiber3.get_account()["lock_arg"], + "capacity": 100000000000, + } in msg["input_cells"] + + def test_standalone_watchtower_rpc_url(self): + """ + 没有pending tlc 的 channel + Returns: + """ + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": True, + } + ) + self.fiber2.start() + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx) + self.fiber1.stop() + self.node.getClient().generate_epochs("0x1", 0) + tx = self.wait_and_check_tx_pool_fee(1000, False, 120 * 5) + self.Miner.miner_until_tx_committed(self.node, tx) + msg = self.get_tx_message(tx) + print("force shutdown tx:", msg) + assert { + "args": self.fiber2.get_account()["lock_arg"], + "capacity": 6199999546, + } in msg["output_cells"] + assert { + "args": self.fiber1.get_account()["lock_arg"], + "capacity": 106199999545, + } in msg["output_cells"] + assert { + "args": self.fiber3.get_account()["lock_arg"], + "capacity": 100000000000, + } in msg["input_cells"] + + def test_2_node(self): + """ + 2个节点挂同一个channel 给瞭望塔 + Returns: + + """ + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": "true", + } + ) + self.fiber2.start() + self.fiber1.stop() + self.fiber1.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": "true", + } + ) + self.fiber1.start() + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber2.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx) + self.node.getClient().generate_epochs("0x1", 0) + + tx = self.wait_and_check_tx_pool_fee(1000, False, 120 * 5) + self.Miner.miner_until_tx_committed(self.node, tx) + + msg = self.get_tx_message(tx) + print("force shutdown tx:", msg) + assert { + "args": self.fiber2.get_account()["lock_arg"], + "capacity": 6199999546, + } in msg["output_cells"] + assert { + "args": self.fiber1.get_account()["lock_arg"], + "capacity": 106199999545, + } in msg["output_cells"] + assert { + "args": self.fiber3.get_account()["lock_arg"], + "capacity": 100000000000, + } in msg["input_cells"] + + def test_watch_node_offline(self): + """ + 瞭望塔节点不在线时，节点启动成功，创建channel 会panic + 我方节点发送交易时，standalone_watchtower不在线, 节点panic: watchtower client call should be ok: Transport(error trying to connect: tcp connect error: Connection refused (os error 61) + Returns: + """ + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": "true", + } + ) + self.fiber3.stop() + self.fiber2.start() + self.fiber2.get_client().node_info() + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber2.get_client().node_info() + + def test_revert_tx(self): + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.fiber2.stop() + self.fiber2.prepare( + { + "fiber_standalone_watchtower_rpc_url": self.fiber3.get_client().url, + "fiber_disable_built_in_watchtower": "true", + } + ) + self.fiber2.start() + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + + self.fiber1.stop() + # back up node1 data + shutil.copytree( + f"{self.fiber1.tmp_path}/fiber", f"{self.fiber1.tmp_path}/fiber.bak" + ) + self.fiber1.start() + time.sleep(5) + # # restart fiber 1 + payment = self.fiber1.get_client().send_payment( + { + "amount": hex(1000 * 100000000), + "target_pubkey": self.fiber2.get_client().node_info()["node_id"], + "keysend": True, + } + ) + self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success") + # # stop fiber1 and back data + self.fiber1.stop() + self.fiber2.stop() + shutil.rmtree(f"{self.fiber1.tmp_path}/fiber") + shutil.copytree( + f"{self.fiber1.tmp_path}/fiber.bak", f"{self.fiber1.tmp_path}/fiber" + ) + self.fiber1.start() + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx_hash) + revocation_tx = self.wait_and_check_tx_pool_fee(1000, False, 100000000) + tx = self.get_tx_message(revocation_tx) + print("revocation tx:", tx) + assert tx["input_cells"][1]["args"] == self.fiber3.get_account()["lock_arg"] + assert tx["output_cells"][0]["args"] == self.fiber2.get_account()["lock_arg"] + assert tx["output_cells"][1]["args"] == self.fiber3.get_account()["lock_arg"] + # assert tx["input_cells"][0]["capacity"] == tx["output_cells"][0]["capacity"] diff --git a/test_cases/fiber/devnet/backup/test_backup.py b/test_cases/fiber/devnet/backup/test_backup.py new file mode 100644 index 0000000..b00cee2 --- /dev/null +++ b/test_cases/fiber/devnet/backup/test_backup.py @@ -0,0 +1,73 @@ +import shutil +import time + +import pytest + +from framework.basic_fiber import FiberTest + + +class TestBackup(FiberTest): + + def test_backup(self): + """ + 1. 关闭节点 + 2. 替换节点 + 3. 重启，send payment + Returns: + """ + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + before_graph_nodes = self.fiber2.get_client().graph_nodes() + self.fiber1.stop() + self.fiber1.prepare({"fiber_listening_addr": "/ip4/127.0.0.1/tcp/8238"}) + self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + time.sleep(5) + after_graph_nodes = self.fiber2.get_client().graph_nodes() + self.send_payment(self.fiber1, self.fiber2, 1) + print(before_graph_nodes) + print(after_graph_nodes) + assert ( + after_graph_nodes["nodes"][1]["addresses"] + == self.fiber1.get_client().node_info()["addresses"] + ) + + def test_backup2(self): + """ + 1. 不关闭节点 + 2. 直接备份数据 + 3. 重启，send payment + Returns: + """ + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + shutil.copytree( + f"{self.fiber1.tmp_path}/fiber", f"{self.fiber1.tmp_path}/fiber.bak" + ) + self.fiber1.stop() + shutil.rmtree(f"{self.fiber1.tmp_path}/fiber") + shutil.copytree( + f"{self.fiber1.tmp_path}/fiber.bak", f"{self.fiber1.tmp_path}/fiber" + ) + self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + time.sleep(5) + self.send_payment(self.fiber1, self.fiber2, 1) + + @pytest.mark.skip("restart ,list_peer will empty ,not stable") + def test_backup3(self): + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber1.stop() + self.fiber1.prepare({"fiber_listening_addr": "/ip4/127.0.0.1/tcp/8238"}) + self.fiber1.start("newPassword2") + time.sleep(5) + self.send_payment(self.fiber1, self.fiber2, 1) + self.fiber1.stop() + self.fiber1.start("newPassword2") + time.sleep(5) + peers = self.fiber1.get_client().list_peers() + self.fiber1.stop() + self.fiber1.start("newPassword2") + self.fiber1.connect_peer(self.fiber2) + time.sleep(8) + peers = self.fiber1.get_client().list_peers() + assert len(peers["peers"]) > 0 + self.send_payment(self.fiber1, self.fiber2, 1) diff --git a/test_cases/fiber/devnet/cancel_invoice/test_cancel_invoice.py b/test_cases/fiber/devnet/cancel_invoice/test_cancel_invoice.py index cbf240d..b73a3aa 100644 --- a/test_cases/fiber/devnet/cancel_invoice/test_cancel_invoice.py +++ b/test_cases/fiber/devnet/cancel_invoice/test_cancel_invoice.py @@ -449,7 +449,7 @@ def test_cancel_invoice_that_statue_is_receive(self): int(before_channel["channels"][0]["local_balance"], 16) - invoice_balance ) - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/654") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/654") def test_batch_cancel(self): """ Test case for batch canceling invoices. @@ -465,7 +465,7 @@ def test_batch_cancel(self): Returns: None """ - cancel_size = 50 + cancel_size = 20 channel_length = 4 # cancel_size = 5 # channel_length = 3 @@ -531,4 +531,4 @@ def test_batch_cancel(self): # Step 6: Verify fiber balance balance = self.get_fiber_balance(self.fibers[0]) - assert balance["local_balance"] == 200000000000 + assert balance["ckb"]["local_balance"] == 200000000000 diff --git a/test_cases/fiber/devnet/compatibility/test_data.py b/test_cases/fiber/devnet/compatibility/test_data.py index 8bd96d4..cbfd685 100644 --- a/test_cases/fiber/devnet/compatibility/test_data.py +++ b/test_cases/fiber/devnet/compatibility/test_data.py @@ -1,28 +1,33 @@ import time +import pytest + from framework.basic_fiber import FiberTest from framework.test_fiber import FiberConfigPath class TestData(FiberTest): - def test_old_fiber_020(self): + @pytest.mark.skip("migration failed") + def test_old_fiber_0311(self): """ - 1. start fiber 0.2.0 - 2. open_channel with fiber - 3. stop fiber - 4. migration and restart fiber 0.3.0 - 5. send_payment - 6. shutdown_channel + 1. start fiber 0.5.0 + 2. open_channel with fiber + 3. stress test with fiber + 4. stop fiber + 5. restart fiber + 6. sleep 10 seconds + 7. restart other fiber + 8. send_payment Returns: """ - # 1. start fiber 0.2.0 + # 1. start fiber 0.5.0 old_fiber_1 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V020_DEV + self.generate_account(10000), fiber_version=FiberConfigPath.V050_DEV ) old_fiber_2 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V020_DEV + self.generate_account(10000), fiber_version=FiberConfigPath.V050_DEV ) old_fiber_1.connect_peer(old_fiber_2) time.sleep(1) @@ -31,177 +36,42 @@ def test_old_fiber_020(self): self.open_channel( old_fiber_1, old_fiber_2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 ) - self.send_payment(old_fiber_1, old_fiber_2, 100) - - # 3. stop fiber - old_fiber_1.stop() - old_fiber_2.stop() - - # 4. migration and restart fiber 0.3.0 - old_fiber_1.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_2.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_1.migration() - old_fiber_1.start() - old_fiber_2.migration() - old_fiber_2.start() - - # 5. send_payment - self.send_payment(old_fiber_1, old_fiber_2, 100) - self.send_payment(old_fiber_2, old_fiber_1, 200) - channels = old_fiber_1.get_client().list_channels({}) - old_fiber_1.get_client().shutdown_channel( - { - "channel_id": channels["channels"][0]["channel_id"], - "close_script": self.get_account_script(self.Config.ACCOUNT_PRIVATE_1), - "fee_rate": "0x3FC", - } - ) - tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120) - tx_message = self.get_tx_message(tx_hash) - print("tx message:", tx_message) - assert { - "args": self.get_account_script(old_fiber_2.account_private)["args"], - "capacity": 106200000000, - } in tx_message["output_cells"] - - def test_old_fiber_021(self): - """ - 1. start fiber 0.2.1 - 2. open_channel with fiber - 3. stop fiber - 4. migration and restart fiber 0.3.0 - 5. send_payment - 6. shutdown_channel - Returns: - - """ - # 1. start fiber 0.2.0 - old_fiber_1 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V021_DEV - ) - old_fiber_2 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V021_DEV - ) - old_fiber_1.connect_peer(old_fiber_2) - time.sleep(1) - # 2. open_channel with fiber - self.open_channel( - old_fiber_1, old_fiber_2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 - ) - self.send_payment(old_fiber_1, old_fiber_2, 100) + # 3. stress test with fiber + for i in range(20): + self.send_payment(old_fiber_1, old_fiber_2, 1, False) + self.send_payment(old_fiber_2, old_fiber_1, 1, False) - # 3. stop fiber + # 4. stop fiber old_fiber_1.stop() - old_fiber_2.stop() - - # 4. migration and restart fiber 0.3.0 - old_fiber_1.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_2.fiber_config_enum = FiberConfigPath.CURRENT_DEV + # 5. restart fiber old_fiber_1.migration() - time.sleep(5) old_fiber_1.start() - time.sleep(5) - old_fiber_2.migration() - old_fiber_2.start() - - # 5. send_payment - self.send_payment(old_fiber_1, old_fiber_2, 100) - self.send_payment(old_fiber_2, old_fiber_1, 200) - channels = old_fiber_1.get_client().list_channels({}) - old_fiber_1.get_client().shutdown_channel( - { - "channel_id": channels["channels"][0]["channel_id"], - "close_script": self.get_account_script(self.Config.ACCOUNT_PRIVATE_1), - "fee_rate": "0x3FC", - } - ) - tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120) - tx_message = self.get_tx_message(tx_hash) - print("tx message:", tx_message) - assert { - "args": self.get_account_script(old_fiber_2.account_private)["args"], - "capacity": 106200000000, - } in tx_message["output_cells"] + # 6. sleep 10 seconds + time.sleep(10) + old_fiber_1.get_client().list_channels({}) - def test_old_fiber_030(self): - # 1. start fiber 0.2.0 - old_fiber_1 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V030_DEV - ) - old_fiber_2 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V030_DEV - ) - old_fiber_1.connect_peer(old_fiber_2) - time.sleep(1) - # 2. open_channel with fiber - self.open_channel( - old_fiber_1, old_fiber_2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 - ) - self.send_payment(old_fiber_1, old_fiber_2, 100) + # todo assert + # self.send_payment(old_fiber_1, old_fiber_2, 1,False) + # list_peers + # old_fiber_1.get_client().list_peers() - # 3. stop fiber - old_fiber_1.stop() + # 7. restart other fiber old_fiber_2.stop() - - # 4. migration and restart fiber 0.3.0 - old_fiber_1.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_2.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_1.migration() - time.sleep(5) - old_fiber_1.start() - time.sleep(5) old_fiber_2.migration() old_fiber_2.start() + time.sleep(10) + # 8. send_payment + self.send_payment(old_fiber_1, old_fiber_2, 1) - # 5. send_payment - self.send_payment(old_fiber_1, old_fiber_2, 100) - self.send_payment(old_fiber_2, old_fiber_1, 200) - channels = old_fiber_1.get_client().list_channels({}) - old_fiber_1.get_client().shutdown_channel( - { - "channel_id": channels["channels"][0]["channel_id"], - "close_script": self.get_account_script(self.Config.ACCOUNT_PRIVATE_1), - "fee_rate": "0x3FC", - } - ) - tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120) - tx_message = self.get_tx_message(tx_hash) - print("tx message:", tx_message) - assert { - "args": self.get_account_script(old_fiber_2.account_private)["args"], - "capacity": 106200000000, - } in tx_message["output_cells"] - - def test_old_fiber_031(self): - # 1. start fiber 0.2.0 - old_fiber_1 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V031_DEV - ) - old_fiber_2 = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V031_DEV - ) - old_fiber_1.connect_peer(old_fiber_2) - time.sleep(1) - # 2. open_channel with fiber - self.open_channel( - old_fiber_1, old_fiber_2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 - ) - self.send_payment(old_fiber_1, old_fiber_2, 100) - - # 3. stop fiber old_fiber_1.stop() - old_fiber_2.stop() # 4. migration and restart fiber 0.3.0 old_fiber_1.fiber_config_enum = FiberConfigPath.CURRENT_DEV - old_fiber_2.fiber_config_enum = FiberConfigPath.CURRENT_DEV old_fiber_1.migration() time.sleep(5) old_fiber_1.start() - time.sleep(5) - old_fiber_2.migration() - old_fiber_2.start() + time.sleep(10) # 5. send_payment self.send_payment(old_fiber_1, old_fiber_2, 100) diff --git a/test_cases/fiber/devnet/compatibility/test_p2p.py b/test_cases/fiber/devnet/compatibility/test_p2p.py index 05b0beb..059b2a7 100644 --- a/test_cases/fiber/devnet/compatibility/test_p2p.py +++ b/test_cases/fiber/devnet/compatibility/test_p2p.py @@ -8,27 +8,28 @@ class TestP2p(FiberTest): - @pytest.mark.skip("not support old fiber") def test_old_fiber(self): """ - 1. start 0.2.0 node - 2. open_channel with node 0.2.0 - 3. send_payment with node 0.2.0 Returns: - """ old_fiber = self.start_new_fiber( - self.generate_account(10000), fiber_version=FiberConfigPath.V020_DEV + self.generate_account(10000), fiber_version=FiberConfigPath.V050_DEV ) old_fiber.connect_peer(self.fiber1) time.sleep(1) - old_fiber.get_client().open_channel( - { - "peer_id": self.fiber1.get_peer_id(), - "funding_amount": hex(1000 + 62 * 100000000), - "tlc_fee_proportional_millionths": hex(1000), - "public": True, - } + with pytest.raises(Exception) as exc_info: + self.fiber1.get_client().open_channel( + { + "peer_id": old_fiber.get_peer_id(), + "funding_amount": hex(1000 + 62 * 100000000), + "tlc_fee_proportional_millionths": hex(1000), + "public": True, + } + ) + expected_error_message = "feature not found" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" ) old_fiber.get_client().open_channel( @@ -39,21 +40,6 @@ def test_old_fiber(self): "public": True, } ) - self.fiber1.get_client().open_channel( - { - "peer_id": old_fiber.get_peer_id(), - "funding_amount": hex(2000 * 100000000), - "tlc_fee_proportional_millionths": hex(1000), - "public": True, - } - ) - self.open_channel( - self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 - ) - with pytest.raises(Exception) as exc_info: - self.send_payment(old_fiber, self.fiber1, 100) - expected_error_message = "no path found" - assert expected_error_message in exc_info.value.args[0], ( - f"Expected substring '{expected_error_message}' " - f"not found in actual string '{exc_info.value.args[0]}'" - ) + time.sleep(1) + channel = old_fiber.get_client().list_channels({}) + assert len(channel["channels"]) == 0 diff --git a/test_cases/fiber/devnet/connect_peer/test_connect_peer.py b/test_cases/fiber/devnet/connect_peer/test_connect_peer.py index 99fbc1a..0f69779 100644 --- a/test_cases/fiber/devnet/connect_peer/test_connect_peer.py +++ b/test_cases/fiber/devnet/connect_peer/test_connect_peer.py @@ -1,5 +1,7 @@ import time +import pytest + from framework.basic_fiber import FiberTest @@ -34,3 +36,15 @@ def test_connect_peer(self): # Step 5: Assert that the peer count is 1 assert node_info["peers_count"] == "0x1" + + @pytest.mark.skip("restart ,list_peer will empty ,not stable") + def test_restart(self): + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + for i in range(5): + self.fiber1.stop() + self.fiber1.start() + peers = self.fiber1.get_client().list_peers() + time.sleep(2) + self.fiber1.get_client().list_channels({}) + peers = self.fiber1.get_client().list_peers() + assert len(peers["peers"]) == 1 diff --git a/test_cases/fiber/devnet/get_invoice/test_get_invoice.py b/test_cases/fiber/devnet/get_invoice/test_get_invoice.py index 6295e12..f7aeb8e 100644 --- a/test_cases/fiber/devnet/get_invoice/test_get_invoice.py +++ b/test_cases/fiber/devnet/get_invoice/test_get_invoice.py @@ -30,6 +30,7 @@ def test_get_exist_new_invoice(self): "final_cltv": "0x28", "payment_preimage": self.generate_random_preimage(), "hash_algorithm": "sha256", + "allow_mpp": True, } ) @@ -42,7 +43,7 @@ def test_get_exist_new_invoice(self): # Step 3: Verify the node ID matches the PayeePublicKey in the invoice assert ( node_info["node_id"] - == result["invoice"]["data"]["attrs"][3]["payee_public_key"] + == result["invoice"]["data"]["attrs"][-1]["payee_public_key"] ) # Step 4: Parse the invoice and verify the parsed result matches the original invoice @@ -57,7 +58,7 @@ def test_get_exist_new_invoice(self): == "test invoice generated by node2" ) assert invoice["invoice"]["data"]["attrs"][1]["expiry_time"] == hex(3600) - assert invoice["invoice"]["data"]["attrs"][2]["hash_algorithm"] == "sha256" + assert invoice["invoice"]["data"]["attrs"][4]["hash_algorithm"] == "sha256" # Step 5: Verify the timestamp of the invoice assert int(int(invoice["invoice"]["data"]["timestamp"], 16) / 1000) == int( diff --git a/test_cases/fiber/devnet/graph_channels/test_graph_channels.py b/test_cases/fiber/devnet/graph_channels/test_graph_channels.py index 15d1da1..523193c 100644 --- a/test_cases/fiber/devnet/graph_channels/test_graph_channels.py +++ b/test_cases/fiber/devnet/graph_channels/test_graph_channels.py @@ -153,7 +153,7 @@ def test_add_channels(self): print("node4_channels", node4_channels) assert len(node4_channels["channels"]) == 2 - @pytest.mark.skip("remove failed ") + # @pytest.mark.skip("remove failed ") def test_remove_channels_with_force(self): """ force close channel @@ -214,21 +214,26 @@ def test_remove_channels_with_force(self): assert len(node3_channels["channels"]) == 1 # force 关闭 channel - N2N3_CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ + N2N3_CHANNEL_ID = self.fiber3.get_client().list_channels({})["channels"][0][ "channel_id" ] self.fiber2.get_client().shutdown_channel( { "channel_id": N2N3_CHANNEL_ID, - "close_script": self.get_account_script(self.fiber1.account_private), - "fee_rate": "0x3FC", "force": True, } ) self.wait_tx_pool(1) for i in range(10): self.Miner.miner_with_version(self.node, "0x0") - time.sleep(5) + self.wait_for_channel_state( + self.fiber3.get_client(), + self.fiber2.get_peer_id(), + "CLOSED", + 60 * 5 + 10, + True, + ) + time.sleep(10) node1_channels = self.fiber1.get_client().graph_channels() node2_channels = self.fiber2.get_client().graph_channels() node3_channels = self.fiber3.get_client().graph_channels() diff --git a/test_cases/fiber/devnet/graph_nodes/test_graph_nodes.py b/test_cases/fiber/devnet/graph_nodes/test_graph_nodes.py index 183b554..3b05e31 100644 --- a/test_cases/fiber/devnet/graph_nodes/test_graph_nodes.py +++ b/test_cases/fiber/devnet/graph_nodes/test_graph_nodes.py @@ -100,6 +100,11 @@ def test_node_info(self): # udt_cfg_infos assert node["udt_cfg_infos"] == node_info["udt_cfg_infos"] + # features + assert ( + node["features"] == node_info["features"] + ), f"node:{node}, node_info:{node_info}" + # @pytest.mark.skip("其他节点的graph_nodes 不一定会更新") def test_change_node_info(self): """ diff --git a/test_cases/fiber/devnet/issue/test_issue_484.py b/test_cases/fiber/devnet/issue/test_issue_484.py index 9f6be45..6fd6183 100644 --- a/test_cases/fiber/devnet/issue/test_issue_484.py +++ b/test_cases/fiber/devnet/issue/test_issue_484.py @@ -14,9 +14,17 @@ def test_484(self): self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000, 1000, 1000 ) payment1 = self.send_payment(self.fiber1, self.fiber2, 600 * 100000000, False) - payment2 = self.send_payment(self.fiber1, self.fiber2, 600 * 100000000, False) + try: + + payment2 = self.send_payment( + self.fiber1, self.fiber2, 600 * 100000000, False, try_count=0 + ) + except Exception as e: + print(f"Expected failure: {e}") + payment2 = None payment3 = self.send_payment(self.fiber1, self.fiber2, 300 * 100000000, False) self.wait_payment_state(self.fiber1, payment1, "Success") - self.wait_payment_state(self.fiber1, payment2, "Failed") + if payment2 != None: + self.wait_payment_state(self.fiber1, payment2, "Failed") self.wait_payment_state(self.fiber1, payment3, "Success") self.send_payment(self.fiber2, self.fiber1, 300 * 100000000) diff --git a/test_cases/fiber/devnet/issue/test_issue_675.py b/test_cases/fiber/devnet/issue/test_issue_675.py new file mode 100644 index 0000000..a5190e3 --- /dev/null +++ b/test_cases/fiber/devnet/issue/test_issue_675.py @@ -0,0 +1,40 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest + + +class TestIssue675(FiberTest): + + def test_shutdown_in_tlc(self): + """""" + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + payments = [] + for i in range(30): + payment = self.send_payment(self.fiber1, self.fiber2, 1 * 100000000, False) + payments.append(payment) + for i in range(10): + try: + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})[ + "channels" + ][0]["channel_id"], + "force": False, + "close_script": self.get_account_script( + self.fiber1.account_private + ), + "fee_rate": "0x3FC", + } + ) + break + except Exception: + time.sleep(1) + + for payment_hash in payments: + self.wait_payment_finished(self.fiber1, payment_hash) + + self.wait_for_channel_state( + self.fiber1.get_client(), self.fiber2.get_peer_id(), "CLOSED", 30, True + ) diff --git a/test_cases/fiber/devnet/list_channels/test_list_channels.py b/test_cases/fiber/devnet/list_channels/test_list_channels.py index b3abe6b..8235069 100644 --- a/test_cases/fiber/devnet/list_channels/test_list_channels.py +++ b/test_cases/fiber/devnet/list_channels/test_list_channels.py @@ -264,7 +264,7 @@ def test_check_channel_result(self): assert channels["channels"][0]["enabled"] is True # tlc_expiry_delta - assert channels["channels"][0]["tlc_expiry_delta"] == hex(86400000) + assert channels["channels"][0]["tlc_expiry_delta"] == hex(14400000) # tlc_fee_proportional_millionths assert channels["channels"][0]["tlc_fee_proportional_millionths"] == hex(1000) diff --git a/test_cases/fiber/devnet/list_peers/test_list_peers.py b/test_cases/fiber/devnet/list_peers/test_list_peers.py index 0607aa5..1e44b64 100644 --- a/test_cases/fiber/devnet/list_peers/test_list_peers.py +++ b/test_cases/fiber/devnet/list_peers/test_list_peers.py @@ -1,8 +1,11 @@ +import pytest + from framework.basic_fiber import FiberTest class TestListPeers(FiberTest): + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/718") def test_01(self): peer = self.fiber1.get_client().list_peers() assert ( @@ -10,10 +13,13 @@ def test_01(self): == self.fiber2.get_client().node_info()["node_id"] ) assert ( - peer["peers"][0]["addresses"] - == self.fiber2.get_client().node_info()["addresses"] + peer["peers"][0]["address"] + in self.fiber2.get_client().node_info()["addresses"] ) assert ( peer["peers"][0]["peer_id"] == self.fiber2.get_client().node_info()["addresses"][0].split("/")[-1] ) + # https://github.com/nervosnetwork/fiber/issues/718 + peers = self.fiber2.get_client().list_peers() + assert len(peers["peers"][0]["address"]) != None diff --git a/test_cases/fiber/devnet/new_invoice/test_amount.py b/test_cases/fiber/devnet/new_invoice/test_amount.py index 9ea1722..95df821 100644 --- a/test_cases/fiber/devnet/new_invoice/test_amount.py +++ b/test_cases/fiber/devnet/new_invoice/test_amount.py @@ -63,7 +63,7 @@ def test_amount_is_zero_or_gt_local_amount(self): "invoice": invoice["invoice_address"], } ) - expected_error_message = "Failed to build route" + expected_error_message = "amount must be greater than 0" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" diff --git a/test_cases/fiber/devnet/node_info/test_node_info.py b/test_cases/fiber/devnet/node_info/test_node_info.py index 4e83ed6..f9618bd 100644 --- a/test_cases/fiber/devnet/node_info/test_node_info.py +++ b/test_cases/fiber/devnet/node_info/test_node_info.py @@ -7,7 +7,7 @@ class TestNodeInfo(FiberTest): - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/631") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/631") def test_commit_hash(self): """ @@ -71,7 +71,7 @@ def test_commit_hash(self): # tlc_max_value # https://github.com/nervosnetwork/fiber/issues/631 - assert node_info["tlc_max_value"] == hex(0) + # assert node_info["tlc_max_value"] == hex(0) # tlc_fee_proportional_millionths assert node_info["tlc_fee_proportional_millionths"] == hex(1000) @@ -79,6 +79,8 @@ def test_commit_hash(self): # peers_count assert node_info["peers_count"] == hex(1) + assert node_info["features"] is not None, "features should not be None" + def test_channel_count(self): """ check channel_count diff --git a/test_cases/fiber/devnet/open_channel/test_commitment_delay_epoch.py b/test_cases/fiber/devnet/open_channel/test_commitment_delay_epoch.py index 6693efc..53e9d21 100644 --- a/test_cases/fiber/devnet/open_channel/test_commitment_delay_epoch.py +++ b/test_cases/fiber/devnet/open_channel/test_commitment_delay_epoch.py @@ -9,7 +9,7 @@ def test_epoch(self): "peer_id": self.fiber2.get_peer_id(), "funding_amount": hex(1000 * 100000000), "public": True, - "commitment_delay_epoch": hex(2), + "commitment_delay_epoch": "0x20001000001", } ) self.wait_for_channel_state( @@ -25,7 +25,9 @@ def test_epoch(self): ) tx_hash = self.wait_and_check_tx_pool_fee(1000, False) self.Miner.miner_until_tx_committed(self.node, tx_hash) - self.node.getClient().generate_epochs(hex(2)) + tip_number = self.node.getClient().get_tip_block_number() + self.node.getClient().generate_epochs("0x20001000001") + after_epoch_number = self.node.getClient().get_tip_block_number() tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 1200) self.Miner.miner_until_tx_committed(self.node, tx_hash) message = self.get_tx_message(tx_hash) diff --git a/test_cases/fiber/devnet/open_channel/test_commitment_fee_rate.py b/test_cases/fiber/devnet/open_channel/test_commitment_fee_rate.py index f570159..398219d 100644 --- a/test_cases/fiber/devnet/open_channel/test_commitment_fee_rate.py +++ b/test_cases/fiber/devnet/open_channel/test_commitment_fee_rate.py @@ -32,11 +32,11 @@ def test_commitment_fee_rate_very_big(self): ) # @pytest.mark.skip("todo") - def test_commitment_fee_rate_exist(self): - """ - commitment_fee_rate != default.value - Returns: - """ + # def test_commitment_fee_rate_exist(self): + # """ + # commitment_fee_rate != default.value + # Returns: + # """ def test_commitment_fee_rate_zero(self): """ diff --git a/test_cases/fiber/devnet/open_channel/test_funding_udt_type_script.py b/test_cases/fiber/devnet/open_channel/test_funding_udt_type_script.py index 8b43a4b..41125d9 100644 --- a/test_cases/fiber/devnet/open_channel/test_funding_udt_type_script.py +++ b/test_cases/fiber/devnet/open_channel/test_funding_udt_type_script.py @@ -27,6 +27,7 @@ def test_funding_udt_type_script_not_exist(self): account3_private, {"ckb_rpc_url": self.node.getClient().url} ) self.fiber3.connect_peer(self.fiber1) + time.sleep(1) self.fiber1.get_client().open_channel( { "peer_id": self.fiber3.get_peer_id(), @@ -178,3 +179,126 @@ def test_funding_udt_type_script_is_white(self): tx_message["output_cells"][1]["args"] == self.fiber2.get_account()["lock_arg"] ) + + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/pull/720") + def test_node1_2_udt_gt_u128_max(self): + self.faucet( + self.fiber1.account_private, + 0, + self.fiber2.account_private, + 340282366920938463463374607431768211400, + ) + self.faucet( + self.fiber1.account_private, 0, self.fiber2.account_private, 1 * 100000000 + ) + # self.open_channel(self.fiber1, self.fiber2, 340282366920938463463374607431768211400 + 1 - 62 * 100000000, 1, + # 1000, 1000, + # self.get_account_udt_script(self.fiber2.account_private)) + temporary_channel = self.fiber1.get_client().open_channel( + { + "peer_id": self.fiber2.get_peer_id(), + "funding_amount": hex(340282366920938463463374607431768211400 + 1), + "tlc_fee_proportional_millionths": hex(1000), + "public": True, + "funding_udt_type_script": self.get_account_udt_script( + self.fiber1.account_private + ), + } + ) + time.sleep(5) + channel = self.fiber1.get_client().list_channels({}) + print("channel:", channel) + assert channel["channels"] == [] + + def test_amount_eq_u128_max(self): + self.faucet( + self.fiber1.account_private, + 0, + self.fiber2.account_private, + 340282366920938463463374607431768211455, + ) + self.faucet( + self.fiber1.account_private, 0, self.fiber2.account_private, 1 * 100000000 + ) + self.open_channel( + self.fiber1, + self.fiber2, + 340282366920938463463374607431768211455 - 1 - 62 * 100000000, + 1, + 1000, + 1000, + self.get_account_udt_script(self.fiber2.account_private), + ) + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "close_script": self.get_account_script(self.Config.ACCOUNT_PRIVATE_1), + "fee_rate": "0x3FC", + } + ) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 100) + self.Miner.miner_until_tx_committed(self.node, tx_hash) + tx_msg = self.get_tx_message(tx_hash) + print("msg:", tx_msg) + assert ( + tx_msg["input_cells"][0]["udt_capacity"] + == 340282366920938463463374607431768211455 + ) + assert { + "args": self.fiber2.get_account()["lock_arg"], + "capacity": 14300000000, + "udt_args": self.get_account_udt_script(self.fiber2.account_private)[ + "args" + ], + "udt_capacity": 1, + } in tx_msg["output_cells"] + assert { + "args": self.fiber1.get_account()["lock_arg"], + "capacity": 14300000000 - tx_msg["fee"], + "udt_args": self.get_account_udt_script(self.fiber2.account_private)[ + "args" + ], + "udt_capacity": 340282366920938463463374607431768211454, + } in tx_msg["output_cells"] + + def test_node1_add_node2_amount_gt_u128_max(self): + """ + Returns: + """ + self.faucet( + self.fiber2.account_private, + 0, + self.fiber1.account_private, + 340282366920938463463374607431768211400, + ) + self.faucet( + self.fiber1.account_private, 0, self.fiber1.account_private, 1 * 100000000 + ) + temporary_channel = self.fiber1.get_client().open_channel( + { + "peer_id": self.fiber2.get_peer_id(), + "funding_amount": hex(100000000 - 1), + "tlc_fee_proportional_millionths": hex(1000), + "public": True, + "funding_udt_type_script": self.get_account_udt_script( + self.fiber1.account_private + ), + } + ) + time.sleep(1) + + with pytest.raises(Exception) as exc_info: + self.fiber2.get_client().accept_channel( + { + "temporary_channel_id": temporary_channel["temporary_channel_id"], + "funding_amount": hex(340282366920938463463374607431768211400 - 1), + "tlc_fee_proportional_millionths": hex(1000), + } + ) + expected_error_message = "The total UDT funding amount should be less than 340282366920938463463374607431768211455" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) diff --git a/test_cases/fiber/devnet/open_channel/test_linked.py b/test_cases/fiber/devnet/open_channel/test_linked.py index 6e2051d..6aa37c1 100644 --- a/test_cases/fiber/devnet/open_channel/test_linked.py +++ b/test_cases/fiber/devnet/open_channel/test_linked.py @@ -32,7 +32,7 @@ def test_unlink_peer(self): } ) - expected_error_message = "pubkey not found" + expected_error_message = "feature not found" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" diff --git a/test_cases/fiber/devnet/open_channel/test_max_tlc_value_in_flight.py b/test_cases/fiber/devnet/open_channel/test_max_tlc_value_in_flight.py index eea2edb..f12ebba 100644 --- a/test_cases/fiber/devnet/open_channel/test_max_tlc_value_in_flight.py +++ b/test_cases/fiber/devnet/open_channel/test_max_tlc_value_in_flight.py @@ -143,7 +143,7 @@ def test_ckb_max_tlc_value_in_flight_too_min(self): "invoice": invoice["invoice_address"], } ) - expected_error_message = "Failed to build route" + expected_error_message = "amount must be greater than 0" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" @@ -256,7 +256,7 @@ def test_udt_max_tlc_value_in_flight_too_min(self): "invoice": invoice["invoice_address"], } ) - expected_error_message = "Failed to build route" + expected_error_message = "amount must be greater than 0" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" @@ -407,14 +407,16 @@ def test_ckb_max_tlc_value_in_flight_not_eq_default(self): "hash_algorithm": "sha256", } ) - before_channel = self.fiber1.get_client().list_channels({}) - - payment = self.fiber1.get_client().send_payment( - { - "invoice": invoice["invoice_address"], - } - ) - self.wait_payment_state(self.fiber1, payment["payment_hash"], "Failed") + # before_channel = self.fiber1.get_client().list_channels({}) + # try: + # payment = self.fiber1.get_client().send_payment( + # { + # "invoice": invoice["invoice_address"], + # } + # ) + # self.wait_payment_state(self.fiber1, payment["payment_hash"], "Failed") + # except Exception as e: + # pass time.sleep(1) # expected_error_message = "TemporaryChannelFailure" # assert expected_error_message in payment["failed_error"] @@ -551,12 +553,12 @@ def test_udt_max_tlc_value_in_flight_not_eq_default(self): ) before_channel = self.fiber1.get_client().list_channels({}) - payment = self.fiber1.get_client().send_payment( - { - "invoice": invoice["invoice_address"], - } - ) - self.wait_payment_state(self.fiber1, payment["payment_hash"], "Failed") + # payment = self.fiber1.get_client().send_payment( + # { + # "invoice": invoice["invoice_address"], + # } + # ) + # self.wait_payment_state(self.fiber1, payment["payment_hash"], "Failed") # expected_error_message = "TemporaryChannelFailure" # assert expected_error_message in payment["failed_error"] # send 1 ckb diff --git a/test_cases/fiber/devnet/open_channel/test_restart.py b/test_cases/fiber/devnet/open_channel/test_restart.py index 7c662b2..ed30d1c 100644 --- a/test_cases/fiber/devnet/open_channel/test_restart.py +++ b/test_cases/fiber/devnet/open_channel/test_restart.py @@ -1,4 +1,6 @@ import time +from os import wait3 + import pytest from framework.basic_fiber import FiberTest @@ -12,13 +14,12 @@ class TestRestart(FiberTest): """ # FiberTest.debug = True - - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/402") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/402") def test_restart_fiber_node_open_channel(self): """ fiber1 <-> fiber2 <-> fiber3 - 1. 我方节点重启：发送openchannel过程中fiber1重启 - 2. 对方节点重启：发送openchannel过程中fiber3重启 + 1. 我方节点重启：发送 open channel 过程中fiber1重启 + 2. 对方节点重启：发送 open channel 过程中fiber3重启 Returns: """ account3_private = self.generate_account(1000) @@ -35,9 +36,20 @@ def test_restart_fiber_node_open_channel(self): ) # channels = self.fiber1.get_client().list_channels({}) # N1N2_CHANNEL_ID = channels["channels"][0] - # 1. 我方节点重启：发送openchannel过程中fiber1重启 + # 1. 我方节点重启：发送open channel过程中fiber1重启 + self.wait_for_channel_state( + self.fiber1.get_client(), + self.fiber2.get_peer_id(), + { + "state_name": "AWAITING_TX_SIGNATURES", + "state_flags": "OUR_TX_SIGNATURES_SENT | THEIR_TX_SIGNATURES_SENT", + }, + 120, + ) self.fiber1.stop() self.fiber1.start() + self.fiber2.stop() + self.fiber2.start() time.sleep(3) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -68,7 +80,7 @@ def test_restart_fiber_node_open_channel(self): print(f"after restart query channel info:{channels}") assert channels["channels"][0]["state"]["state_name"] == "CHANNEL_READY" - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/402") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/402") def test_restart_ckb_node_openchannel(self): """ 1. ckb节点重启：发送openchannel过程中ckb节点重启 @@ -91,7 +103,8 @@ def test_restart_ckb_node_openchannel(self): # 1. ckb节点重启：发送openchannel过程中ckb节点重启 self.node.stop() self.node.start() - self.Miner.make_tip_height_number(self.node, 20) + for i in range(20): + self.Miner.miner_with_version(self.node, "0x0") time.sleep(3) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -139,7 +152,10 @@ def test_restart_channel_ready(self): # 1、ready的状态后重启发送端节点，观察channel的状态是否会变 self.fiber1.stop() self.fiber1.start() - time.sleep(3) + # todo 目前重启可能连不上对方节点，不是很稳定 + self.fiber1.connect_peer(self.fiber2) + self.fiber2.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber2.get_client().node_info() print(f"node info detail:{node_info}") assert int(node_info["peers_count"], 16) == 2 @@ -149,6 +165,9 @@ def test_restart_channel_ready(self): # 2、ready的状态后重启接收端端节点，观察channel的状态是否会变 self.fiber3.stop() self.fiber3.start() + # todo 目前重启可能连不上对方节点，不是很稳定 + self.fiber3.connect_peer(self.fiber1) + self.fiber3.connect_peer(self.fiber2) time.sleep(3) node_info = self.fiber2.get_client().node_info() print(f"node info detail:{node_info}") @@ -159,7 +178,8 @@ def test_restart_channel_ready(self): # 3、重启下ckb节点 self.node.stop() self.node.start() - self.Miner.make_tip_height_number(self.node, 20) + for i in range(20): + self.Miner.miner_with_version(self.node, "0x0") time.sleep(3) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -187,3 +207,29 @@ def test_restart_channel_ready(self): self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success", 120) channels = self.fiber3.get_client().list_channels({}) assert channels["channels"][0]["local_balance"] == hex(10 * 100000000) + + def test_restart_with_open_n_channel(self): + for i in range(5): + self.start_new_fiber(self.generate_account(100000)) + # self.start_new_mock_fiber("") + for i in range(1, 7): + self.fiber1.connect_peer(self.fibers[i]) + time.sleep(1) + for j in range(500): + for i in range(1, 7): + self.fibers[i].get_client().open_channel( + { + "peer_id": self.fiber1.get_peer_id(), + "funding_amount": hex(1000 * 100000000), + "public": True, + } + ) + time.sleep(0.1) + self.fiber1.stop() + self.fiber1.start() + time.sleep(30) + for fiber in self.fibers: + channels = fiber.get_client().list_channels({}) + for channel in channels["channels"]: + print(channel["state"]["state_name"]) + assert channel["state"]["state_name"] == "CHANNEL_READY" diff --git a/test_cases/fiber/devnet/open_channel/test_tlc_expiry_delta.py b/test_cases/fiber/devnet/open_channel/test_tlc_expiry_delta.py index 3f64c35..aaa0074 100644 --- a/test_cases/fiber/devnet/open_channel/test_tlc_expiry_delta.py +++ b/test_cases/fiber/devnet/open_channel/test_tlc_expiry_delta.py @@ -31,24 +31,26 @@ def test_tlc_expiry_delta_is_zero_or_bigger(self): # "tlc_fee_proportional_millionths": "0x4B0", } ) - expected_error_message = ( - "TLC expiry delta is too small, expect larger than 900000" - ) + expected_error_message = "TLC expiry delta is too small, expect larger than" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" ) - temporary_channel_id = self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(200 * 100000000), - "public": True, - "tlc_expiry_delta": "0xffffffff", - # "tlc_fee_proportional_millionths": "0x4B0", - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY", 120 + + with pytest.raises(Exception) as exc_info: + self.fiber1.get_client().open_channel( + { + "peer_id": self.fiber2.get_peer_id(), + "funding_amount": hex(200 * 100000000), + "public": True, + "tlc_expiry_delta": "0xffffffff", + # "tlc_fee_proportional_millionths": "0x4B0", + } + ) + expected_error_message = "expected to be smaller than" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" ) @pytest.mark.skip("todo") diff --git a/test_cases/fiber/devnet/send_payment/debug/test_with_debug.py b/test_cases/fiber/devnet/send_payment/debug/test_with_debug.py index c23be6c..9218633 100644 --- a/test_cases/fiber/devnet/send_payment/debug/test_with_debug.py +++ b/test_cases/fiber/devnet/send_payment/debug/test_with_debug.py @@ -91,7 +91,10 @@ def test_not_hophit_issue620(self): print(f"b-a,channel:{channels}") ba_channel_outpoint = channels["channels"][0]["channel_outpoint"] print(f"b-a, channel_outpoint:{ba_channel_outpoint}") - assert payment["router"][0]["channel_outpoint"] == ba_channel_outpoint + assert ( + payment["routers"][0]["nodes"][0]["channel_outpoint"] + == ba_channel_outpoint + ) except Exception as e: # 如果走的是b-c-d-a，不通过hophit应该发送失败 error_message = str(e) diff --git a/test_cases/fiber/devnet/send_payment/module/test_send_payment.py b/test_cases/fiber/devnet/send_payment/module/test_send_payment.py index e65df5f..72a9a87 100644 --- a/test_cases/fiber/devnet/send_payment/module/test_send_payment.py +++ b/test_cases/fiber/devnet/send_payment/module/test_send_payment.py @@ -395,24 +395,28 @@ def test_send_payment_each_other(self): { "target_pubkey": self.fiber3.get_client().node_info()["node_id"], "currency": "Fibd", - "amount": hex(1 * 100000000), + "amount": hex(100 * 100000000), "keysend": True, # "payment_hash": self.generate_random_preimage(), } ) - self.wait_payment_state(self.fiber1, payment1["payment_hash"], "Success") + self.wait_payment_state(self.fiber1, payment1["payment_hash"], "Success", 30) time.sleep(1) node1_pubkey = self.fiber1.get_client().node_info()["node_id"] node3_pubkey = self.fiber3.get_client().node_info()["node_id"] - for i in range(100): - payment1 = self.fiber1.get_client().send_payment( - { - "target_pubkey": node3_pubkey, - "currency": "Fibd", - "amount": hex(100), - "keysend": True, - } - ) + for i in range(20): + print("current i:", i) + try: + payment1 = self.fiber1.get_client().send_payment( + { + "target_pubkey": node3_pubkey, + "currency": "Fibd", + "amount": hex(100), + "keysend": True, + } + ) + except Exception as e: + pass payment2 = self.fiber3.get_client().send_payment( { "target_pubkey": node1_pubkey, @@ -422,8 +426,8 @@ def test_send_payment_each_other(self): # "payment_hash": self.generate_random_preimage(), } ) - self.wait_payment_state(self.fiber1, payment1["payment_hash"], "Success") - self.wait_payment_state(self.fiber3, payment2["payment_hash"], "Success") + self.wait_payment_finished(self.fiber1, payment1["payment_hash"], 20) + self.wait_payment_finished(self.fiber3, payment2["payment_hash"], 20) time.sleep(10) self.fiber2.get_client().node_info() diff --git a/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_shutdown.py b/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_shutdown.py index 00c29be..16a4d35 100644 --- a/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_shutdown.py +++ b/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_shutdown.py @@ -4,8 +4,7 @@ class TestSendPaymentWithShutdown(FiberTest): - - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/503") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/503") def test_shutdown_in_send_payment(self): self.start_new_fiber(self.generate_account(10000)) self.start_new_fiber(self.generate_account(10000)) @@ -84,13 +83,13 @@ def test_force_shutdown_in_send_payment(self): self.fibers[3].get_client().shutdown_channel( { "channel_id": N3N4_CHANNEL_ID, - "close_script": { - "code_hash": "0x1bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8", - "hash_type": "type", - "args": self.fibers[3].get_account()["lock_arg"], - }, + # "close_script": { + # "code_hash": "0x1bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8", + # "hash_type": "type", + # "args": self.fibers[3].get_account()["lock_arg"], + # }, "force": True, - "fee_rate": "0x3FC", + # "fee_rate": "0x3FC", } ) tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120) diff --git a/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_update_channel.py b/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_update_channel.py index 7593a9d..b865e45 100644 --- a/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_update_channel.py +++ b/test_cases/fiber/devnet/send_payment/module/test_send_payment_with_update_channel.py @@ -29,10 +29,13 @@ def test_01(self): for j in range(3): # Send initial payments for i in range(30): - payment_hash = self.send_payment( - self.fibers[0], self.fibers[3], 100000000, False - ) - payment_hashes.append(payment_hash) + try: + payment_hash = self.send_payment( + self.fibers[0], self.fibers[3], 100000000, False, None, 0 + ) + payment_hashes.append(payment_hash) + except: + pass # Get channel ID and update channel N3N4_CHANNEL_ID = ( @@ -54,10 +57,13 @@ def test_01(self): # Send additional payments for i in range(30): - payment_hash = self.send_payment( - self.fibers[0], self.fibers[3], 100000000, False - ) - payment_hashes.append(payment_hash) + try: + payment_hash = self.send_payment( + self.fibers[0], self.fibers[3], 100000000, False, None, 0 + ) + payment_hashes.append(payment_hash) + except: + pass payment_results = [] diff --git a/test_cases/fiber/devnet/send_payment/mpp/test_demo.py b/test_cases/fiber/devnet/send_payment/mpp/test_demo.py new file mode 100644 index 0000000..6ddabb7 --- /dev/null +++ b/test_cases/fiber/devnet/send_payment/mpp/test_demo.py @@ -0,0 +1,24 @@ +import time + +from framework.basic_fiber import FiberTest +from framework.test_fiber import FiberConfigPath + + +class TestMppDemo(FiberTest): + + def test_mpp_demo(self): + """ + open channel with mpp + + Returns: + + """ + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0) + for i in range(10): + print(f"-----current--{i}") + self.send_invoice_payment(self.fiber1, self.fiber2, 2100 * 100000000) + self.send_invoice_payment(self.fiber2, self.fiber1, 2100 * 100000000) + fiber_balance = self.get_fiber_balance(self.fiber1) + assert fiber_balance["ckb"]["local_balance"] == 3000 * 100000000 diff --git a/test_cases/fiber/devnet/send_payment/mpp/test_mpp_bench.py b/test_cases/fiber/devnet/send_payment/mpp/test_mpp_bench.py new file mode 100644 index 0000000..558639f --- /dev/null +++ b/test_cases/fiber/devnet/send_payment/mpp/test_mpp_bench.py @@ -0,0 +1,151 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest + + +class MppBench(FiberTest): + + def test_bench_self(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + + time.sleep(10) + payments = [[]] + for i in range(100): + for i in range(3): + try: + payment_hash = self.send_invoice_payment( + self.fibers[i], + self.fibers[i], + 1001 * 100000000, + False, + try_count=0, + ) + payments[i].append(payment_hash) + except: + pass + for i in range(len(payments)): + for payment_hash in payments[i]: + self.wait_payment_finished(self.fibers[i], payment_hash, 1000) + time.sleep(200) + self.get_fiber_graph_balance() + for i in range(3): + payment_hash = self.send_invoice_payment( + self.fibers[i], self.fibers[i], 100 * 100000000, True + ) + for fiber in self.fibers: + fiber1_channels = fiber.get_client().list_channels({}) + for channel in fiber1_channels["channels"]: + fiber.get_client().shutdown_channel( + { + "channel_id": channel["channel_id"], + "close_script": self.get_account_script(fiber.account_private), + "fee_rate": "0x3FC", + # "force": True, + } + ) + shutdown_tx_hash = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx_hash) + shutdown_tx = self.get_tx_message(shutdown_tx_hash) + print("Shutdown tx :", shutdown_tx) + print("tx message:", channel) + assert { + "args": self.get_account_script(fiber.account_private)["args"], + "capacity": int(channel["local_balance"], 16) + + 62 * 100000000 + - shutdown_tx["fee"], + } in shutdown_tx["output_cells"] + + @pytest.mark.skip("not stable: stop cause mutilSig Err") + def test_bench_self_with_stop(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + + time.sleep(10) + payments = [[]] + for i in range(100): + for i in range(3): + try: + payment_hash = self.send_invoice_payment( + self.fibers[i], + self.fibers[i], + 1001 * 100000000, + False, + try_count=0, + ) + payments[i].append(payment_hash) + except: + pass + self.fibers[2].stop() + time.sleep(100) + self.send_payment(self.fiber1, self.fiber2, 1 * 100000000) + self.send_payment(self.fiber2, self.fiber1, 1 * 100000000) + time.sleep(100) + self.send_payment(self.fiber1, self.fiber2, 1 * 100000000) + self.send_payment(self.fiber2, self.fiber1, 1 * 100000000) + self.fibers[2].start() + self.send_payment(self.fiber1, self.fiber2, 1 * 100000000) + self.send_payment(self.fiber2, self.fiber1, 1 * 100000000) + self.get_fiber_graph_balance() + self.fiber1.connect_peer(self.fibers[2]) + self.fiber2.connect_peer(self.fibers[2]) + time.sleep(200) + for fiber in self.fibers: + balance = self.get_fiber_balance(fiber) + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + for i in range(3): + for i in range(3): + payment_hash = self.send_payment( + self.fibers[i], self.fibers[i], 1 * 100000000, True, try_count=3 + ) + for fiber in self.fibers: + balance = self.get_fiber_balance(fiber) + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + # for i in range(len(payments)): + # for payment_hash in payments[i]: + # self.wait_payment_finished(self.fibers[i], payment_hash, 1000) + # time.sleep(200) + # self.get_fiber_graph_balance() + # for i in range(3): + # payment_hash = self.send_invoice_payment( + # self.fibers[i], + # self.fibers[i], + # 100 * 100000000, + # True + # ) + # for fiber in self.fibers: + # fiber1_channels = fiber.get_client().list_channels({}) + # for channel in fiber1_channels['channels']: + # fiber.get_client().shutdown_channel({ + # "channel_id": channel['channel_id'], + # "close_script": self.get_account_script(fiber.account_private), + # "fee_rate": "0x3FC", + # # "force": True, + # }) + # shutdown_tx_hash = self.wait_and_check_tx_pool_fee(1000, False) + # self.Miner.miner_until_tx_committed(self.node, shutdown_tx_hash) + # shutdown_tx = self.get_tx_message(shutdown_tx_hash) + # print("Shutdown tx :", shutdown_tx) + # print("tx message:", channel) + # assert {'args': self.get_account_script(fiber.account_private)['args'], + # 'capacity': int(channel['local_balance'],16)+ 62 *100000000 - shutdown_tx['fee']} in shutdown_tx['output_cells'] diff --git a/test_cases/fiber/devnet/send_payment/mpp/test_mpp_force_shutdown.py b/test_cases/fiber/devnet/send_payment/mpp/test_mpp_force_shutdown.py new file mode 100644 index 0000000..e69de29 diff --git a/test_cases/fiber/devnet/send_payment/mpp/test_mpp_with_watch_tower.py b/test_cases/fiber/devnet/send_payment/mpp/test_mpp_with_watch_tower.py new file mode 100644 index 0000000..e69de29 diff --git a/test_cases/fiber/devnet/send_payment/mpp/test_mutil_path.py b/test_cases/fiber/devnet/send_payment/mpp/test_mutil_path.py new file mode 100644 index 0000000..27b9193 --- /dev/null +++ b/test_cases/fiber/devnet/send_payment/mpp/test_mutil_path.py @@ -0,0 +1,777 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest + + +class MutilPathTestCase(FiberTest): + # debug = True + + def test_mutil_to_one(self): + """ + 多-1(a->c) + - a-1-b-1-c + - a-2-b-1-c + - a-1-d-1-b-1-c + - a-2-d-1-b-1-c + Returns: + """ + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + # self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[3], self.fibers[2], 2000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 2000 * 100000000, 0, 0, 0) + for i in range(10): + time.sleep(2) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 4000 * 100000000) + time.sleep(2) + self.send_invoice_payment(self.fibers[2], self.fibers[0], 4000 * 100000000) + + # @pytest.mark.skip("This test is not stable, needs to be fixed") + def test_mutil_to_one_2(self): + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[3], self.fibers[2], 2000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 2000 * 100000000, 0, 0, 0) + + time.sleep(2) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 2000 * 100000000) + time.sleep(2) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 2000 * 100000000) + time.sleep(2) + try: + self.send_invoice_payment(self.fibers[0], self.fibers[2], 2000 * 100000000) + except Exception as e: + pass + self.send_invoice_payment(self.fibers[2], self.fibers[0], 2000 * 100000000) + self.send_invoice_payment(self.fibers[2], self.fibers[0], 2000 * 100000000) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 1 * 100000000) + + def test_mutil_to_one_3(self): + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel( + self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 1000, 1000 + ) + self.open_channel( + self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 1000, 1000 + ) + + self.open_channel( + self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 1000, 1000 + ) + self.open_channel( + self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 1000, 1000 + ) + + self.open_channel( + self.fibers[3], self.fibers[2], 2000 * 100000000, 0, 1000, 1000 + ) + self.open_channel( + self.fibers[1], self.fibers[2], 2000 * 100000000, 0, 1000, 1000 + ) + self.wait_graph_channels_sync(self.fiber1, 6) + self.wait_graph_channels_sync(self.fiber2, 6) + self.wait_graph_channels_sync(self.fibers[2], 6) + self.wait_graph_channels_sync(self.fibers[3], 6) + # print("channels len:", len(channels["channels"])) + for i in range(3): + self.send_invoice_payment(self.fibers[0], self.fibers[2], 1000 * 100000000) + for i in range(10): + self.send_invoice_payment(self.fibers[2], self.fibers[0], 2000 * 100000000) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 2000 * 100000000) + + def test_one_to_mutil(self): + """ + - a-1-b-1-c + - a-1-b-2-c + - a-1-b-1-d-1-c + Returns: + + """ + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel(self.fibers[0], self.fibers[1], 3000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[1], self.fibers[3], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[3], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 3000 * 100000000) + self.send_invoice_payment(self.fibers[2], self.fibers[0], 3000 * 100000000) + + def test_one_mutil_one(self): + """ + a-1-b-1-c-1-d + a-1-b-2-c-1-d + a-1-b-1-e-1-c-1-d + a-1-b-2-e-2-c-1-d + Returns: + """ + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel(self.fibers[0], self.fibers[1], 4000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[1], self.fibers[4], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[4], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[4], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[4], self.fibers[2], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[2], self.fibers[3], 4000 * 100000000, 0, 0, 0) + self.send_invoice_payment(self.fibers[0], self.fibers[3], 4000 * 100000000) + self.send_invoice_payment(self.fibers[3], self.fibers[0], 4000 * 100000000) + + def test_mutil_mutil(self): + """ + a-1-b-1-c + a-2-b-2-c + a-1-d-1-c + a-2-d-2-c + Returns: + """ + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[1], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[0], self.fibers[3], 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fibers[3], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[3], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fibers[1], self.fibers[2], 1000 * 100000000, 0, 0, 0) + self.send_invoice_payment(self.fibers[0], self.fibers[2], 4000 * 100000000) + self.send_invoice_payment(self.fibers[2], self.fibers[0], 4000 * 100000000) + + def test_one_one_limit(self): + N = 30 + for i in range(1, N): + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + time.sleep(3) + self.send_invoice_payment(self.fiber1, self.fiber2, 1000 * 100000000 * i) + self.send_invoice_payment(self.fiber2, self.fiber1, 1000 * 100000000 * i) + + def test_one_mid_one_limit(self): + for i in range(1, 20): + print("current N:", i) + fiber = self.start_new_fiber( + self.generate_account( + 10000, self.fiber1.account_private, 1000 * 100000000 + ) + ) + self.open_channel(fiber, self.fiber2, 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber1, fiber, 1000 * 100000000, 0, 0, 0) + self.send_invoice_payment(self.fiber1, self.fiber2, 1000 * 100000000 * i) + self.send_invoice_payment(self.fiber2, self.fiber1, 1000 * 100000000 * i) + + # def test_hold_timeout(self): + # """ + # todo 模拟一个支付在中途被阻断的情况 + # Returns: + # + # """ + # self.fiber3 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # + # self.fiber4 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # self.fiber5 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # + # self.open_channel(self.fiber1, self.fiber3, 1000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber3, self.fiber4, 1000 * 100000000, 0, 0, 0) + # + # self.open_channel(self.fiber1, self.fiber2, 2000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber2, self.fiber5, 2000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber5, self.fiber4, 1000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber5, self.fiber4, 1000 * 100000000, 0, 0, 0) + # time.sleep(1) + # payment = self.send_invoice_payment( + # self.fiber1, self.fiber4, 3000 * 100000000, False + # ) + # time.sleep(0.05) + # # self.fiber4.get_client().c + # # self.wait_payment_state(self.fiber1, payment,"Inflight",interval=0.1) + # self.fiber5.stop() + # self.wait_payment_state(self.fiber1, payment, "Failed") + # time.sleep(200) + # # self.get_fiber_graph_balance() + # self.fiber5.start() + # time.sleep(200) + # self.get_fibers_balance_message() + # # payment_hash = self.send_payment(self.fiber1, self.fiber4, 100 * 100000000,False) + + # def test_hold_timeout2(self): + # """ + # todo 模拟一个支付在中途被阻断的情况 + # todo 添加断言 + # Returns: + # + # """ + # self.fiber3 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # + # self.fiber4 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # self.fiber5 = self.start_new_fiber( + # self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + # ) + # + # self.open_channel(self.fiber1, self.fiber3, 1000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber3, self.fiber4, 1000 * 100000000, 0, 0, 0) + # + # self.open_channel(self.fiber1, self.fiber2, 2000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber2, self.fiber5, 2000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber5, self.fiber4, 1000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber5, self.fiber4, 1000 * 100000000, 0, 0, 0) + # + # time.sleep(10) + # payment = self.send_invoice_payment( + # self.fiber1, self.fiber4, 3000 * 100000000, False + # ) + # # self.wait_payment_state(self.fiber1, payment,"Inflight",interval=0.1) + # self.fiber5.stop() + # self.wait_payment_state(self.fiber1, payment, "Failed") + # time.sleep(200) + # self.fiber5.start() + # time.sleep(200) + # self.get_fiber_graph_balance() + + def test_transfer_self(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + payments = [[], [], []] + for i in range(30): + # self.send_invoice_payment(self.fiber1,self.fiber1,2000 * 100000000,False) + for i in range(3): + try: + payment_hash = self.send_invoice_payment( + self.fibers[i], + self.fibers[i], + 1001 * 100000000, + False, + None, + try_count=0, + ) + payments[i].append(payment_hash) + except: + pass + for i in range(3): + for payment_hash in payments[i]: + self.wait_payment_finished(self.fibers[i], payment_hash, 1000) + time.sleep(200) + for fiber in self.fibers: + balance = self.get_fiber_balance(fiber) + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + assert balance["ckb"]["local_balance"] == 200000000000 + + for i in range(3): + self.send_invoice_payment( + self.fibers[i], self.fibers[i], 100 * 100000000, True, None + ) + + def test_transfer_self_3(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber3, self.fiber1, 1000 * 100000000, 0, 0, 0) + + # self.fiber1.stop() + self.faucet( + self.fiber1.account_private, + 10000, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber1, + self.fiber2, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + self.open_channel( + self.fiber1, + self.fiber2, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + self.faucet( + self.fiber2.account_private, + 10000, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber2, + self.fiber3, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + self.open_channel( + self.fiber2, + self.fiber3, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + self.faucet( + self.fiber3.account_private, + 10000, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber3, + self.fiber1, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + self.open_channel( + self.fiber3, + self.fiber1, + 1000 * 100000000, + 0, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + time.sleep(10) + payments = [[], [], []] + for i in range(100): + # self.send_invoice_payment(self.fiber1,self.fiber1,2000 * 100000000,False) + for i in range(3): + try: + payment_hash = self.send_invoice_payment( + self.fibers[i], + self.fibers[i], + 1001 * 100000000, + False, + None, + try_count=0, + ) + payments[i].append(payment_hash) + except: + pass + # todo 断言 udt channel 不会被使用 + time.sleep(200) + resend = False + for i in range(3): + for payment_hash in payments[i]: + invoice = ( + self.fibers[i] + .get_client() + .get_invoice({"payment_hash": payment_hash}) + ) + if invoice["status"] == "Open": + payment = ( + self.fibers[i] + .get_client() + .get_payment({"payment_hash": payment_hash}) + ) + assert payment["status"] == "Failed" + try: + payment = ( + self.fibers[i] + .get_client() + .send_payment( + { + "invoice": invoice["invoice_address"], + "allow_self_payment": True, + } + ) + ) + self.wait_payment_finished( + self.fibers[i], payment["payment_hash"] + ) + resend = True + except Exception as e: + pass + assert resend == True + time.sleep(200) + for fiber in self.fibers: + balance = self.get_fiber_balance(fiber) + print(balance) + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + for key in balance.keys(): + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + if key == "ckb": + assert balance["ckb"]["local_balance"] == 200000000000 + elif key == "chain": + continue + else: + assert balance[key]["local_balance"] == 212400000000 + + def test_split(self): + """ + 去掉了 余额最小值PAYMENT_MAX_PARTS_LIMIT:10000 + Returns: + """ + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber1, 1000 * 100000000, 10000 - 1, 0, 0) + self.send_invoice_payment( + self.fiber1, self.fiber2, 1000 * 100000000 + 10000 - 1 + ) + + def test_max_fee(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.fiber4 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 2000, 0) + + self.open_channel(self.fiber1, self.fiber4, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber4, self.fiber3, 1000 * 100000000, 0, 1000, 0) + # self.open_channel(self.fiber4, self.fiber3, 1000 * 100000000, 0, 0, 0) + + time.sleep(1) + invoice = self.fiber3.get_client().new_invoice( + { + "amount": hex(1000 * 100000000), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + "allow_mpp": True, + } + ) + payment = self.fiber1.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + # "max_fee_amount": hex(109890100), + } + ) + print("payment:", payment) + + def test_not_use_false_router1(self): + """ + 拆分router 不会选择false的router + Returns: + """ + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 3000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 0, 0, 0) + channels = self.fiber2.get_client().list_channels( + { + "peer_id": self.fiber3.get_peer_id(), + } + ) + channel_id = channels["channels"][0]["channel_id"] + self.fibers[1].get_client().update_channel( + {"channel_id": channels["channels"][0]["channel_id"], "enabled": False} + ) + time.sleep(1) + + with pytest.raises(Exception) as exc_info: + # self.send_invoice_payment(self.fiber1, self.fiber2, 1000 * 100000000 + 10000 - 1) + self.send_invoice_payment(self.fiber1, self.fiber3, 3000 * 100000000) + expected_error_message = "no path found" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.send_invoice_payment(self.fiber1, self.fiber3, 2000 * 100000000) + channels = self.fiber2.get_client().list_channels( + { + "peer_id": self.fiber3.get_peer_id(), + } + ) + for channel in channels["channels"]: + if channel["channel_id"] == channel_id: + assert channel["local_balance"] == hex(1000 * 100000000) + + def test_private_channel(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.fiber1.get_client().open_channel( + { + "peer_id": self.fiber2.get_peer_id(), + "funding_amount": hex(1062 * 100000000), + "public": False, + } + ) + self.wait_for_channel_state( + self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" + ) + # self.fiber1.get_client().open_channel({ + # "peer_id": self.fiber1.get_peer_id(), + # "funding_amount": hex(1000 * 100000000), + # "public": True, + # }) + # self.wait_for_channel_state(self.fiber1, self.fiber2.get_peer_id(), "CHANNEL_READY") + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + time.sleep(10) + self.send_invoice_payment(self.fiber1, self.fiber2, 2000 * 100000000) + self.open_channel(self.fiber3, self.fiber2, 2000 * 100000000, 0, 0, 0) + time.sleep(10) + with pytest.raises(Exception) as exc_info: + self.send_invoice_payment(self.fiber3, self.fiber1, 2000 * 100000000) + expected_error_message = "no path found" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + + @pytest.mark.skip("todo") + def test_mini_value(self): + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + channels = self.fiber1.get_client().list_channels({}) + self.fiber1.get_client().update_channel( + { + "channel_id": channels["channels"][0]["channel_id"], + "tlc_minimum_value": hex(10 * 100000000), + } + ) + self.fiber1.get_client().update_channel( + { + "channel_id": channels["channels"][1]["channel_id"], + "tlc_minimum_value": hex(10 * 100000000), + } + ) + time.sleep(10) + self.send_invoice_payment(self.fiber1, self.fiber2, 1001 * 100000000) + + # with pytest.raises(Exception) as exc_info: + # expected_error_message = "no path found" + # assert expected_error_message in exc_info.value.args[0], ( + # f"Expected substring '{expected_error_message}' " + # f"not found in actual string '{exc_info.value.args[0]}'" + # ) + + def test_cancel_invoice(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 3000 * 100000000, 0, 0, 0) + time.sleep(1) + for i in range(100): + payment_hash = self.send_invoice_payment( + self.fiber1, self.fiber3, 1 * 100000000, False + ) + self.fiber3.get_client().cancel_invoice({"payment_hash": payment_hash}) + time.sleep(200) + self.get_fiber_graph_balance() + for fiber in self.fibers[:2]: + balance = self.get_fiber_balance(fiber) + assert balance["ckb"]["offered_tlc_balance"] == 0 + assert balance["ckb"]["received_tlc_balance"] == 0 + assert balance["ckb"]["local_balance"] == 3000 * 100000000 + + @pytest.mark.skip("cost half") + def test_invoice_diff_sender_cost_two(self): + """ + 1->2->3 + 4->5->3 + 双花 + Returns: + """ + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.fiber4 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.fiber5 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 3000 * 100000000, 0, 0, 0) + + self.open_channel(self.fiber4, self.fiber5, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber4, self.fiber5, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber4, self.fiber5, 1000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber5, self.fiber3, 3000 * 100000000, 0, 0, 0) + time.sleep(5) + invoice = self.fiber3.get_client().new_invoice( + { + "amount": hex(3000 * 100000000), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + "allow_atomic_mpp": True, + } + ) + self.fiber1.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + "max_fee_amount": hex(1000000), + } + ) + self.fiber4.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + "max_fee_amount": hex(1000000), + } + ) + + self.wait_payment_finished( + self.fiber1, invoice["invoice"]["data"]["payment_hash"] + ) + self.wait_payment_finished( + self.fiber4, invoice["invoice"]["data"]["payment_hash"] + ) + + self.get_fiber_graph_balance() + # todo 只能有1笔成功 + + @pytest.mark.skip("cost two account same time") + def test_invoice_same_sender_cost_two(self): + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 1000 * 100000000) + ) + self.open_channel(self.fiber1, self.fiber2, 2000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber1, self.fiber2, 2000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber1, self.fiber2, 2000 * 100000000, 0, 0, 0) + self.open_channel(self.fiber2, self.fiber3, 4000 * 100000000, 0, 0, 0) + # self.open_channel(self.fiber2, self.fiber3, 4000 * 100000000, 0, 0, 0) + + time.sleep(5) + invoice = self.fiber3.get_client().new_invoice( + { + "amount": hex(3000 * 100000000), + "currency": "Fibd", + "description": "test invoice generated by node2", + # "expiry": "0xe10", + # "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + "allow_mpp": True, + # "allow_atomic_mpp": True, + } + ) + payment = self.fiber1.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + "max_fee_amount": hex(1000000), + } + ) + with pytest.raises(Exception) as exc_info: + self.fiber1.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + "max_fee_amount": hex(1000000), + } + ) + expected_error_message = "Payment session already exists" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.wait_payment_finished(self.fiber1, payment["payment_hash"], 30) + balance = self.get_fiber_balance(self.fiber3) + assert balance["ckb"]["local_balance"] == 300000000000 diff --git a/test_cases/fiber/devnet/send_payment/offline/test_force_restart.py b/test_cases/fiber/devnet/send_payment/offline/test_force_restart.py index 965e2d4..659c2ac 100644 --- a/test_cases/fiber/devnet/send_payment/offline/test_force_restart.py +++ b/test_cases/fiber/devnet/send_payment/offline/test_force_restart.py @@ -60,7 +60,9 @@ def test_restart_node_send_payment_key_send(self): # 1. 发送端强制重启，send_payment self.fiber1.force_stop() self.fiber1.start() - time.sleep(3) + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 node3_info = self.fiber3.get_client().node_info() @@ -79,7 +81,9 @@ def test_restart_node_send_payment_key_send(self): # 2. 中间节点2强制重启 send_payment self.fiber2.force_stop() self.fiber2.start() - time.sleep(3) + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber2.get_client().node_info() assert node_info["peers_count"] == "0x2" payment = self.fiber1.get_client().send_payment( @@ -97,7 +101,9 @@ def test_restart_node_send_payment_key_send(self): # 3. 最终节点强制重启 send_payment self.fiber3.force_stop() self.fiber3.start() - time.sleep(3) + self.fiber3.connect_peer(self.fiber2) + self.fiber3.connect_peer(self.fiber1) + time.sleep(5) node_info = self.fiber3.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 payment = self.fiber1.get_client().send_payment( @@ -151,6 +157,8 @@ def test_restart_node_send_payment_invoice(self): # 1. 发送端强制重启，send_payment self.fiber1.force_stop() self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) time.sleep(3) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -177,7 +185,9 @@ def test_restart_node_send_payment_invoice(self): # 2. 中间节点2强制重启 send_payment self.fiber2.force_stop() self.fiber2.start() - time.sleep(3) + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber2.get_client().node_info() assert node_info["peers_count"] == "0x2" invoice = self.fiber3.get_client().new_invoice( @@ -204,6 +214,8 @@ def test_restart_node_send_payment_invoice(self): # 3. 最终节点强制重启 send_payment self.fiber3.force_stop() self.fiber3.start() + self.fiber3.connect_peer(self.fiber1) + self.fiber3.connect_peer(self.fiber2) time.sleep(3) node_info = self.fiber3.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -228,7 +240,7 @@ def test_restart_node_send_payment_invoice(self): channels = self.fiber3.get_client().list_channels({}) assert channels["channels"][0]["local_balance"] == hex(30 * 100000000) - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/363") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/363") def test_restart_when_node_send_payment_begin_node(self): account3_private = self.generate_account(1000) self.fiber3 = self.start_new_fiber(account3_private) @@ -299,17 +311,18 @@ def test_restart_when_node_send_payment_begin_node(self): channels = self.fiber3.get_client().list_channels({}) print("channels:", channels) self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) time.sleep(5) for payment in payments: self.wait_payment_finished(self.fiber1, payment["payment_hash"], 120) - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/363") + @pytest.mark.skip("Musig2RoundFinalizeError") def test_restart_when_node_send_payment_mid_node(self): - self.fiber3 = self.start_new_mock_fiber("") - # self.fiber3 = self.start_new_fiber(self.generate_account(1000)) - # self.open_channel(self.fiber1, self.fiber2, 200 * 100000000, 1) - # self.open_channel(self.fiber2, self.fiber3, 200 * 100000000, 1) + self.fiber3 = self.start_new_fiber(self.generate_account(1000)) + self.open_channel(self.fiber1, self.fiber2, 200 * 100000000, 1) + self.open_channel(self.fiber2, self.fiber3, 200 * 100000000, 1) # 2. 中间节点2强制重启 send_payment for i in range(2): @@ -321,8 +334,7 @@ def test_restart_when_node_send_payment_mid_node(self): "amount": hex(10 * 100000000), "currency": "Fibd", "description": "test invoice generated by node2", - "expiry": "0xe10", - "final_cltv": "0x28", + "expiry": "0xe1000", "payment_preimage": self.generate_random_preimage(), "hash_algorithm": "sha256", } @@ -346,6 +358,8 @@ def test_restart_when_node_send_payment_mid_node(self): contains_pending = True assert contains_pending == True self.fiber2.start() + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) time.sleep(5) for payment in payments: self.wait_payment_finished(self.fiber1, payment["payment_hash"], 120) diff --git a/test_cases/fiber/devnet/send_payment/offline/test_restart.py b/test_cases/fiber/devnet/send_payment/offline/test_restart.py index 49ba5e5..2202e39 100644 --- a/test_cases/fiber/devnet/send_payment/offline/test_restart.py +++ b/test_cases/fiber/devnet/send_payment/offline/test_restart.py @@ -60,7 +60,9 @@ def test_restart_node_send_payment_key_send(self): # 1. 发送端重启，send_payment self.fiber1.stop() self.fiber1.start() - time.sleep(3) + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 node3_info = self.fiber3.get_client().node_info() @@ -79,7 +81,9 @@ def test_restart_node_send_payment_key_send(self): # 2. 中间节点2重启 send_payment self.fiber2.stop() self.fiber2.start() - time.sleep(3) + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) + time.sleep(5) node_info = self.fiber2.get_client().node_info() assert node_info["peers_count"] == "0x2" payment = self.fiber1.get_client().send_payment( @@ -97,7 +101,9 @@ def test_restart_node_send_payment_key_send(self): # 3. 最终节点重启 send_payment self.fiber3.stop() self.fiber3.start() - time.sleep(3) + self.fiber3.connect_peer(self.fiber2) + self.fiber3.connect_peer(self.fiber1) + time.sleep(5) node_info = self.fiber3.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 payment = self.fiber1.get_client().send_payment( @@ -151,6 +157,8 @@ def test_restart_node_send_payment_invoice(self): # 1. 发送端重启，send_payment self.fiber1.stop() self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) time.sleep(3) node_info = self.fiber1.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -177,6 +185,8 @@ def test_restart_node_send_payment_invoice(self): # 2. 中间节点2重启 send_payment self.fiber2.stop() self.fiber2.start() + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) time.sleep(3) node_info = self.fiber2.get_client().node_info() assert node_info["peers_count"] == "0x2" @@ -204,6 +214,8 @@ def test_restart_node_send_payment_invoice(self): # 3. 最终节点重启 send_payment self.fiber3.stop() self.fiber3.start() + self.fiber3.connect_peer(self.fiber2) + self.fiber3.connect_peer(self.fiber1) time.sleep(3) node_info = self.fiber3.get_client().node_info() assert int(node_info["peers_count"], 16) >= 1 @@ -238,6 +250,8 @@ def test_send_stop(self): self.send_payment(self.fiber1, self.fiber3, 1) self.fiber3.stop() self.fiber3.start() + self.fiber3.connect_peer(self.fiber2) + self.fiber3.connect_peer(self.fiber1) self.send_payment(self.fiber1, self.fiber3, 2) @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/363") @@ -304,6 +318,8 @@ def test_restart_when_node_send_payment(self): # todo 如果 fiber1 不启动了 # todo check fiber2 钱是否会丢 self.fiber1.start() + self.fiber1.connect_peer(self.fiber2) + self.fiber1.connect_peer(self.fiber3) self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success", 120) channels = self.fiber3.get_client().list_channels({}) @@ -344,6 +360,8 @@ def test_restart_when_node_send_payment(self): print("fiber2 list channels:", channelsN23) self.fiber2.start() + self.fiber2.connect_peer(self.fiber1) + self.fiber2.connect_peer(self.fiber3) self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success", 120) channels = self.fiber3.get_client().list_channels({}) assert channels["channels"][0]["local_balance"] == hex(20 * 100000000) @@ -375,5 +393,7 @@ def test_restart_when_node_send_payment(self): ) print("self.fiber3.stop() payment:", payment) self.fiber3.start() + self.fiber3.connect_peer(self.fiber2) + self.fiber3.connect_peer(self.fiber1) self.wait_payment_finished(self.fiber1, payment["payment_hash"], 120) self.send_payment(self.fiber1, self.fiber2, 1) diff --git a/test_cases/fiber/devnet/send_payment/offline/test_stop_mid_node.py b/test_cases/fiber/devnet/send_payment/offline/test_stop_mid_node.py index f18965d..ede3daa 100644 --- a/test_cases/fiber/devnet/send_payment/offline/test_stop_mid_node.py +++ b/test_cases/fiber/devnet/send_payment/offline/test_stop_mid_node.py @@ -7,7 +7,7 @@ class TestStopMidNode(FiberTest): - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/464") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/464") def test_stop_mid_node(self): """ diff --git a/test_cases/fiber/devnet/send_payment/params/test_custom_records.py b/test_cases/fiber/devnet/send_payment/params/test_custom_records.py index 983fa79..fb4cca6 100644 --- a/test_cases/fiber/devnet/send_payment/params/test_custom_records.py +++ b/test_cases/fiber/devnet/send_payment/params/test_custom_records.py @@ -79,7 +79,7 @@ def test_custom(self): # 单独的key custom_records = {} - for i in range(0, 100): + for i in range(0, 20): custom_records.update({hex(i): self.generate_random_preimage()}) payment = self.fiber1.get_client().send_payment( { @@ -107,7 +107,7 @@ def test_custom(self): "keysend": True, "allow_self_payment": True, "custom_records": { - "0xffffffff": "0x1234", + hex(65535): "0x1234", "0x0": "0x5678", }, } @@ -120,7 +120,7 @@ def test_custom(self): } ) assert { - "0xffffffff": "0x1234", + "0xffff": "0x1234", "0x0": "0x5678", } == payment["custom_records"] @@ -133,12 +133,12 @@ def test_custom(self): "keysend": True, "allow_self_payment": True, "custom_records": { - "0xffffffff": self.generate_random_str(13000), + "0x12": self.generate_random_str(4096 + 2), # "0x0": "0x5678", }, } ) - expected_error_message = "HopDataLenTooLarge" + expected_error_message = "value can not more than 2048 bytes" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" diff --git a/test_cases/fiber/devnet/send_payment/params/test_hophint.py b/test_cases/fiber/devnet/send_payment/params/test_hophint.py index 31f23e6..d71dc06 100644 --- a/test_cases/fiber/devnet/send_payment/params/test_hophint.py +++ b/test_cases/fiber/devnet/send_payment/params/test_hophint.py @@ -179,7 +179,7 @@ def test_use_hophit(self): print(f"d-a, channel_outpoint:{da_channel_outpoint}") # b-a,怎么填d-私-a的信息 - payment_hash = ( + payment = ( self.fibers[1] .get_client() .send_payment( # b @@ -195,20 +195,13 @@ def test_use_hophit(self): # 填的是 d 的 pubkey，表示在 d 节点使用 channel_outpoint 到 a "channel_outpoint": da_channel_outpoint, "fee_rate": hex(1000), - "tlc_expiry_delta": hex(1000), + "tlc_expiry_delta": hex(86400000), } ], } ) ) - - payment = ( - self.fibers[1] - .get_client() - .get_payment({"payment_hash": payment_hash["payment_hash"]}) - ) - print("payment", payment) - assert payment["status"] == "Created" + self.wait_payment_state(self.fibers[1], payment["payment_hash"], "Success", 120) def test_use_hophit_simple(self): """ @@ -256,7 +249,7 @@ def test_use_hophit_simple(self): print(f"d-a, channel_outpoint:{da_channel_outpoint}") # b-a,怎么填d-私-a的信息 - payment_hash = ( + payment = ( self.fibers[1] .get_client() .send_payment( # b @@ -273,16 +266,10 @@ def test_use_hophit_simple(self): ], # 填的是 d 的 pubkey，表示在 d 节点使用 channel_outpoint 到 a "channel_outpoint": da_channel_outpoint, "fee_rate": hex(1000), - "tlc_expiry_delta": hex(1000), + "tlc_expiry_delta": hex(86400000), } ], } ) ) - payment = ( - self.fibers[1] - .get_client() - .get_payment({"payment_hash": payment_hash["payment_hash"]}) - ) - print("payment", payment) - assert payment["status"] == "Created" + self.wait_payment_state(self.fibers[1], payment["payment_hash"], "Success", 120) diff --git a/test_cases/fiber/devnet/send_payment/params/test_max_fee_amount.py b/test_cases/fiber/devnet/send_payment/params/test_max_fee_amount.py index 29a1002..baf81d0 100644 --- a/test_cases/fiber/devnet/send_payment/params/test_max_fee_amount.py +++ b/test_cases/fiber/devnet/send_payment/params/test_max_fee_amount.py @@ -75,11 +75,30 @@ def test_fee(self): ) self.wait_payment_state(self.fiber1, payment1["payment_hash"]) - # - # - # def test_max_fee_amount_is_none(self): - # """ - # max_fee_amount == node 代表什么 - # Returns: - # - # """ + # @pytest.mark.skip(reason="https://github.com/nervosnetwork/fiber/pull/717") + def test_max_fee_0xffffffffffffffffffffffffffffffff(self): + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + invoice = self.fiber1.get_client().new_invoice( + { + "amount": hex(1 * 100000000), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + } + ) + with pytest.raises(Exception) as exc_info: + self.fiber2.get_client().send_payment( + { + "invoice": invoice["invoice_address"], + "max_fee_amount": "0xffffffffffffffffffffffffffffffff", + } + ) + expected_error_message = "overflow" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + self.fiber2.get_client().node_info() diff --git a/test_cases/fiber/devnet/shutdown_channel/test_channel_id.py b/test_cases/fiber/devnet/shutdown_channel/test_channel_id.py index e5bc6b8..2f098a1 100644 --- a/test_cases/fiber/devnet/shutdown_channel/test_channel_id.py +++ b/test_cases/fiber/devnet/shutdown_channel/test_channel_id.py @@ -18,7 +18,7 @@ def test_channel_id_not_exist(self): "fee_rate": "0x3FC", } ) - expected_error_message = "Messaging failed because channel is closed" + expected_error_message = "Channel not found error" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" diff --git a/test_cases/fiber/devnet/shutdown_channel/test_force.py b/test_cases/fiber/devnet/shutdown_channel/test_force.py index eb927da..2f22b65 100644 --- a/test_cases/fiber/devnet/shutdown_channel/test_force.py +++ b/test_cases/fiber/devnet/shutdown_channel/test_force.py @@ -16,7 +16,7 @@ class TestForce(FiberTest): - xxx """ - # FiberTest.debug = True + start_fiber_config = {"fiber_funding_timeout_seconds": 10} # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/333") def test_node_offline(self): @@ -62,7 +62,7 @@ def test_node_offline(self): "fee_rate": "0x3FC", } ) - expected_error_message = "Messaging failed because channel is closed" + expected_error_message = "Channel not found error" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" @@ -506,6 +506,7 @@ def test_in_tx_offline(self): # self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success") + @pytest.mark.skip("todo") def test_ShuttingDown(self): temporary_channel_id = self.fiber1.get_client().open_channel( { @@ -533,13 +534,13 @@ def test_ShuttingDown(self): } ) time.sleep(1) - - channels = self.fiber1.get_client().list_channels( - {"peer_id": self.fiber2.get_peer_id()} - ) + fiber2_peer_id = self.fiber2.get_peer_id() + channels = self.fiber1.get_client().list_channels({"peer_id": fiber2_peer_id}) N1N2_CHANNEL_ID = channels["channels"][0]["channel_id"] + self.fiber2.stop() + time.sleep(5) + self.fiber1.get_client().disconnect_peer({"peer_id": self.fiber2.get_peer_id()}) - # 5. Send payment using the created invoice self.fiber1.get_client().shutdown_channel( { "channel_id": N1N2_CHANNEL_ID, @@ -552,12 +553,12 @@ def test_ShuttingDown(self): # "force": True } ) - self.fiber2.get_client().shutdown_channel( - { - "channel_id": N1N2_CHANNEL_ID, - "force": True, - } - ) + # self.fiber2.get_client().shutdown_channel( + # { + # "channel_id": N1N2_CHANNEL_ID, + # "force": True, + # } + # ) # todo add check def test_force_ckb(self): @@ -690,3 +691,42 @@ def test_force_udt(self): ) print("after_account:", after_account) # todo check + + def test_force_not_link_check_graph_channel(self): + self.fiber3 = self.start_new_fiber(self.generate_random_preimage()) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.fiber1.connect_peer(self.fiber3) + self.fiber2.connect_peer(self.fiber3) + self.fiber1.get_client().disconnect_peer({"peer_id": self.fiber2.get_peer_id()}) + + self.fiber1.get_client().shutdown_channel( + { + "channel_id": self.fiber1.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False) + self.Miner.miner_until_tx_committed(self.node, tx_hash) + self.node.getClient().generate_epochs("0x6", wait_time=0) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120 * 5) + self.Miner.miner_until_tx_committed(self.node, tx_hash) + self.wait_for_channel_state( + self.fiber1.get_client(), + self.fiber2.get_peer_id(), + "CLOSED", + 10 + 5 * 60, + include_closed=True, + ) + self.wait_for_channel_state( + self.fiber2.get_client(), + self.fiber1.get_peer_id(), + "CLOSED", + 10 + 5 * 60, + include_closed=True, + ) + time.sleep(5) + for fiber in self.fibers: + channels = fiber.get_client().graph_channels({}) + assert channels["channels"] == [] diff --git a/test_cases/fiber/devnet/stable/test_stable.py b/test_cases/fiber/devnet/stable/test_stable.py new file mode 100644 index 0000000..887ca66 --- /dev/null +++ b/test_cases/fiber/devnet/stable/test_stable.py @@ -0,0 +1,159 @@ +import time + +from framework.basic_fiber import FiberTest +import concurrent.futures + + +class TestStableStress(FiberTest): + fnn_log_level = "info" + + # def test_conn(self): + # self. + def test_stable_stress(self): + """ + a->b->c->a + 1. a->a ckb and udt + 2. b->b ckb and udt + 3. c->c ckb and udt + Returns: + """ + self.fiber3 = self.start_new_fiber( + self.generate_account(10000, self.fiber1.account_private, 10000 * 100000000) + ) + self.faucet( + self.fiber2.account_private, + 0, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.faucet( + self.fiber1.account_private, + 0, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000, 0, 0 + ) + self.open_channel( + self.fiber1, + self.fiber2, + 1000 * 100000000, + 1000 * 100000000, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + self.open_channel( + self.fiber2, self.fiber3, 1000 * 100000000, 1000 * 100000000, 0, 0 + ) + self.open_channel( + self.fiber2, + self.fiber3, + 1000 * 100000000, + 1000 * 100000000, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + self.open_channel( + self.fiber3, self.fiber1, 1000 * 100000000, 1000 * 100000000, 0, 0 + ) + self.open_channel( + self.fiber3, + self.fiber1, + 1000 * 100000000, + 1000 * 100000000, + 0, + 0, + self.get_account_udt_script(self.fiber1.account_private), + ) + + time.sleep(10) + udt = self.get_account_udt_script(self.fiber1.account_private) + send_tx_size = 5 * 60 * 60 * 2 + tasks_submitted = 0 + start_time = time.time() + times = [] + completed_counts = [] + with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor: + futures = [] + + for i in range(send_tx_size): + # Submit payment tasks for fiber1 + futures.append( + executor.submit(self.send_payment, self.fiber1, self.fiber1, 1) + ) + futures.append( + executor.submit( + self.send_payment, self.fiber1, self.fiber1, 1, True, udt + ) + ) + + futures.append( + executor.submit(self.send_payment, self.fiber2, self.fiber2, 1) + ) + futures.append( + executor.submit( + self.send_payment, self.fiber2, self.fiber2, 1, True, udt + ) + ) + + futures.append( + executor.submit(self.send_payment, self.fiber3, self.fiber3, 1) + ) + futures.append( + executor.submit( + self.send_payment, self.fiber3, self.fiber3, 1, True, udt + ) + ) + tasks_submitted += 6 + + # Wait for all tasks to complete + # concurrent.futures.wait(futures) + completed_tasks = 0 + for future in concurrent.futures.as_completed(futures): + completed_tasks += 1 + try: + result = future.result() + self.logger.debug( + f"Task {completed_tasks}/{tasks_submitted} completed" + ) + except Exception as e: + self.logger.error( + f"Task {completed_tasks}/{tasks_submitted} failed: {e}" + ) + + # Record time and completed tasks + elapsed_time = time.time() - start_time + times.append(elapsed_time) + completed_counts.append(completed_tasks) + + if completed_tasks % 100 == 0: + speed = completed_tasks / elapsed_time if elapsed_time > 0 else 0 + self.logger.info( + f"Completed {completed_tasks}/{tasks_submitted} tasks in {elapsed_time:.2f} seconds. Speed: {speed:.2f} tasks/second" + ) + + total_time = time.time() - start_time + speed = completed_tasks / total_time if total_time > 0 else 0 + self.logger.info( + f"Completed {completed_tasks}/{tasks_submitted} tasks in {total_time:.2f} seconds. Final speed: {speed:.2f} tasks/second" + ) + + self.logger.info(f"finished :{send_tx_size}") + self.get_fibers_balance_message() + for fiber in self.fibers: + message = self.get_fiber_balance(fiber) + assert message["ckb"] == { + "local_balance": 200000000000, + "offered_tlc_balance": 0, + "received_tlc_balance": 0, + } + assert message[udt["args"]] == { + "local_balance": 206200000000, + "offered_tlc_balance": 0, + "received_tlc_balance": 0, + } diff --git a/test_cases/fiber/devnet/update_channel/test_channel_id.py b/test_cases/fiber/devnet/update_channel/test_channel_id.py index ebc7d77..b1e7de5 100644 --- a/test_cases/fiber/devnet/update_channel/test_channel_id.py +++ b/test_cases/fiber/devnet/update_channel/test_channel_id.py @@ -13,7 +13,7 @@ def test_channel_id_not_exist(self): self.fiber1.get_client().update_channel( {"channel_id": self.generate_random_preimage()} ) - expected_error_message = "Messaging failed because channel is closed" + expected_error_message = "Channel not found error" assert expected_error_message in exc_info.value.args[0], ( f"Expected substring '{expected_error_message}' " f"not found in actual string '{exc_info.value.args[0]}'" diff --git a/test_cases/fiber/devnet/wasm/README.md b/test_cases/fiber/devnet/wasm/README.md new file mode 100644 index 0000000..42ecf49 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/README.md @@ -0,0 +1,22 @@ +### prepare +start wasm version fiber +```angular2html +export FIBER_REPO=https://github.com/nervosnetwork/fiber.git +export FIBER_BRANCH=develop +git clone https://github.com/gpBlockchain/fiber-wasm-demo.git +bash prepare.sh +``` + +stop wasm versipn fiber +```angular2html +kill -9 $(lsof -ti:8000) +kill -9 $(lsof -ti:9000) +``` + +restart wasm version fiber +```angular2html +python3 server.py > server.log 2>&1 & +echo "run e2e" +cd fiber-wasm-client-rpc +npm run service > service.log 2>&1 & +``` \ No newline at end of file diff --git a/test_cases/fiber/devnet/wasm/test_connect_peer.py b/test_cases/fiber/devnet/wasm/test_connect_peer.py new file mode 100644 index 0000000..e1f3b61 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_connect_peer.py @@ -0,0 +1,42 @@ +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class ConnectPeer(FiberTest): + + def test_connect_20_nodes(self): + + account_private = self.generate_account( + 1000000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet", + ) + + for i in range(20): + self.start_new_fiber(self.generate_account(10000)) + for i in range(len(self.fibers)): + self.open_channel( + wasmFiber, self.fibers[i], 1000 * 100000000, 1000 * 100000000 + ) + + payments = [] + invoices = [] + for i in range(len(self.fibers)): + payment_hash = self.send_invoice_payment( + self.fibers[i], wasmFiber, 1 * 100000000, False + ) + invoices.append(payment_hash) + payment_hash = self.send_payment( + wasmFiber, self.fibers[i], 1 * 100000000, False + ) + payments.append(payment_hash) + print("invoices", invoices) + print("payments", payments) + for i in range(len(payments)): + self.wait_payment_finished(wasmFiber, payments[i], 1000) + for i in range(len(invoices)): + self.wait_invoice_state(wasmFiber, invoices[i]) diff --git a/test_cases/fiber/devnet/wasm/test_wasm.py b/test_cases/fiber/devnet/wasm/test_wasm.py new file mode 100644 index 0000000..92933a3 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm.py @@ -0,0 +1,94 @@ +# import time +# +# from framework.basic_fiber import FiberTest +# from framework.test_wasm_fiber import WasmFiber +# +# +# class TestWasm(FiberTest): +# debug = True +# +# def test_two_wasm(self): +# self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) +# +# def test_0001234(self): +# self.fiber1.get_client().node_info() +# self.fiber2.get_client().node_info() +# +# def test_facue1(self): +# # self.faucet("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", 10000) +# self.faucet("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c1", 10000) +# +# +# def test_wasm(self): +# """ +# Test the wasm module. +# """ +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", "devnet") +# self.fiber1.get_client().node_info() +# wasmFiber.connect_peer(self.fiber2) +# +# def test_facue(self): +# self.faucet("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", 10000, +# self.Config.ACCOUNT_PRIVATE_1, 1000 * 100000000) +# +# def test_open_channel(self): +# """ +# Open a channel with the wasm fiber. +# """ +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", "devnet") +# self.open_channel(wasmFiber, self.fiber2, 1000 * 100000000, 1000 * 100000000) +# self.open_channel(wasmFiber, self.fiber1, 1000 * 100000000, 1000 * 100000000) +# +# self.fiber1.get_client().node_info() +# self.fiber2.get_client().node_info() +# +# def test_balala(self): +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", "devnet", True) +# channel_id = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# for i in range(10000): +# self.fiber1.get_client().update_channel( +# { +# "channel_id": channel_id, +# "tlc_fee_proportional_millionths": hex(20000 + i), +# } +# ) +# wasmFiber.get_client().update_channel({ +# "channel_id": channel_id, +# "tlc_fee_proportional_millionths": hex(2000 + i), +# }) +# time.sleep(0.01) +# +# def test_000(self): +# self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) +# +# def test_send_payment(self): +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", "devnet") +# for i in range(100): +# self.send_payment(wasmFiber, self.fiber2, 1 * 100000000, False) +# +# def test_false(self): +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", +# "devnet", +# True) +# for i in range(10000): +# self.send_payment(wasmFiber, wasmFiber, 1 * 100000000, True) +# self.send_payment(self.fiber1, self.fiber1, 1 * 100000000, True) +# self.send_payment(self.fiber2, self.fiber2, 1 * 100000000, True) +# +# def test_00(self): +# # self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0) +# # self.send_payment(self.fiber1, self.fiber2, 100 * 100000000, True) +# # self.fiber1.start() +# wasmFiber = WasmFiber("2db2219027d6c2a206856fed962214cfa47ab1b3da322ce051877c6567bac2c8", +# "0201010101010101010101010101010101010101010101010101010101010101", "devnet", True) +# # for i in range(100): +# # self.send_payment(wasmFiber,self.fiber2,88,False) +# wasmFiber.get_client().node_info() +# # self.fiber1.stop() diff --git a/test_cases/fiber/devnet/wasm/test_wasm_bench.py b/test_cases/fiber/devnet/wasm/test_wasm_bench.py new file mode 100644 index 0000000..ee01ce5 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm_bench.py @@ -0,0 +1,100 @@ +import pytest + +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class TestWasmBench(FiberTest): + + # @pytest.mark.skip("todo") + def test_ckb_bench(self): + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet", + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + self.open_channel(wasmFiber, self.fiber1, 1000 * 100000000, 1000 * 100000000) + self.send_payment(wasmFiber, self.fiber2, 1 * 100000000) + self.send_payment(self.fiber2, wasmFiber, 1 * 100000000) + + self.faucet( + self.fiber1.account_private, + 10000, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber1, + self.fiber2, + 1000 * 100000000, + 1000 * 100000000, + udt=self.get_account_udt_script(self.fiber1.account_private), + ) + self.open_channel( + wasmFiber, + self.fiber1, + 1000 * 100000000, + 1000 * 100000000, + udt=self.get_account_udt_script(self.fiber1.account_private), + ) + wasmPaymentHashes = [] + fiber2PaymentHashes = [] + for i in range(50): + try: + paymentHash = self.send_payment( + wasmFiber, + self.fiber2, + 1 * 100000000, + False, + self.get_account_udt_script(self.fiber1.account_private), + try_count=0, + ) + wasmPaymentHashes.append(paymentHash) + paymentHash = self.send_payment( + self.fiber2, + wasmFiber, + 1 * 100000000, + False, + self.get_account_udt_script(self.fiber1.account_private), + try_count=0, + ) + fiber2PaymentHashes.append(paymentHash) + except Exception as e: + pass + + for i in range(len(wasmPaymentHashes)): + self.wait_payment_finished(wasmFiber, wasmPaymentHashes[i]) + for i in range(len(fiber2PaymentHashes)): + self.wait_payment_finished(self.fiber2, fiber2PaymentHashes[i]) + + # wasmFiber.get_client().shutdown_channel({ + # "channel_id": wasmFiber.get_client().list_channels({})["channels"][0][ + # "channel_id" + # ], + # "close_script": self.get_account_script(account_private), + # "fee_rate": "0x3FC", + # }) + # self.wait_for_channel_state(wasmFiber.get_client(), self.fiber1.get_peer_id(), "CLOSED", include_closed=True) + # wasmFiber.get_client().shutdown_channel({ + # "channel_id": wasmFiber.get_client().list_channels({})["channels"][0][ + # "channel_id" + # ], + # "close_script": self.get_account_script(account_private), + # "fee_rate": "0x3FC", + # }) + # self.wait_for_channel_state(wasmFiber.get_client(), self.fiber1.get_peer_id(), "CLOSED", include_closed=True) + # assert len(wasmFiber.get_client().list_channels({})["channels"]) == 0 + # node_info0 = wasmFiber.get_client().node_info() + # + # wasmFiber.refresh() + # node_info1 = wasmFiber.get_client().node_info() + # wasmFiber.stop() + # wasmFiber.start() + # node_info2 = wasmFiber.get_client().node_info() + # assert node_info1 == node_info2 + # assert node_info0 == node_info1 diff --git a/test_cases/fiber/devnet/wasm/test_wasm_demo.py b/test_cases/fiber/devnet/wasm/test_wasm_demo.py new file mode 100644 index 0000000..5fd09e7 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm_demo.py @@ -0,0 +1,99 @@ +import time + +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class WasmDemo(FiberTest): + + def test_ckb_udt_demo(self): + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet", + ) + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + self.open_channel(wasmFiber, self.fiber1, 1000 * 100000000, 1000 * 100000000) + self.send_payment(wasmFiber, self.fiber2, 1 * 100000000) + self.send_payment(self.fiber2, wasmFiber, 1 * 100000000) + + self.faucet( + self.fiber1.account_private, + 10000, + self.fiber1.account_private, + 10000 * 100000000, + ) + self.open_channel( + self.fiber1, + self.fiber2, + 1000 * 100000000, + 1000 * 100000000, + udt=self.get_account_udt_script(self.fiber1.account_private), + ) + self.open_channel( + wasmFiber, + self.fiber1, + 1000 * 100000000, + 1000 * 100000000, + udt=self.get_account_udt_script(self.fiber1.account_private), + ) + self.send_payment( + wasmFiber, + self.fiber2, + 1 * 100000000, + True, + self.get_account_udt_script(self.fiber1.account_private), + ) + self.send_payment( + self.fiber2, + wasmFiber, + 1 * 100000000, + True, + self.get_account_udt_script(self.fiber1.account_private), + ) + + wasmFiber.get_client().shutdown_channel( + { + "channel_id": wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "close_script": self.get_account_script(account_private), + "fee_rate": "0x3FC", + } + ) + self.wait_for_channel_state( + wasmFiber.get_client(), + self.fiber1.get_peer_id(), + "CLOSED", + include_closed=True, + ) + shutdown_channel_id = wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ] + wasmFiber.get_client().shutdown_channel( + { + "channel_id": shutdown_channel_id, + "close_script": self.get_account_script(account_private), + "fee_rate": "0x3FC", + } + ) + time.sleep(1) + self.wait_for_channel_state( + wasmFiber.get_client(), + self.fiber1.get_peer_id(), + "CLOSED", + include_closed=True, + channel_id=shutdown_channel_id, + ) + assert len(wasmFiber.get_client().list_channels({})["channels"]) == 0 + node_info0 = wasmFiber.get_client().node_info() + + wasmFiber.refresh() + node_info1 = wasmFiber.get_client().node_info() + node_info2 = wasmFiber.get_client().node_info() + assert node_info1["node_id"] == node_info2["node_id"] + assert node_info0["node_id"] == node_info1["node_id"] diff --git a/test_cases/fiber/devnet/wasm/test_wasm_mutil.py b/test_cases/fiber/devnet/wasm/test_wasm_mutil.py new file mode 100644 index 0000000..0aca60c --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm_mutil.py @@ -0,0 +1,32 @@ +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class MutilWasm(FiberTest): + def test_mutil(self): + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber1 = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet", + databasePrefix="wasm1", + ) + account_private2 = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + wasmFiber2 = WasmFiber( + account_private2, + "2201010101010101010101010101010101010101010101010101010101010101", + "devnet", + databasePrefix="wasm2", + ) + self.open_channel(wasmFiber1, self.fiber1, 1000 * 100000000, 1000 * 100000000) + self.open_channel(wasmFiber2, self.fiber1, 1000 * 100000000, 1000 * 100000000) + self.open_channel(wasmFiber2, self.fiber2, 1000 * 100000000, 1000 * 100000000) + self.open_channel(wasmFiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) + for i in range(20): + self.send_invoice_payment(wasmFiber1, wasmFiber1, 1 * 100000000) + self.send_invoice_payment(wasmFiber2, wasmFiber2, 1 * 100000000) diff --git a/test_cases/fiber/devnet/wasm/test_wasm_rpc.py b/test_cases/fiber/devnet/wasm/test_wasm_rpc.py new file mode 100644 index 0000000..0265751 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm_rpc.py @@ -0,0 +1,233 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class WasmRpcTest(FiberTest): + """ + Test cases for the Wasm RPC interface. + """ + + def test_wasm_rpc(self): + """ + Test the Wasm RPC interface. + """ + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet", + ) + time.sleep(1) + wasmFiber.connect_peer(self.fiber1) + time.sleep(1) + # abandon_channel + wasmFiber.get_client().open_channel( + { + "peer_id": self.fiber1.get_peer_id(), + "funding_amount": hex(1000 * 100000000 + 62 * 100000000), + "public": True, + } + ) + self.wait_for_channel_state( + wasmFiber.get_client(), self.fiber1.get_peer_id(), "AWAITING_TX_SIGNATURES" + ) + pending_channel_id = wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ] + with pytest.raises(Exception) as exc_info: + wasmFiber.get_client().abandon_channel({"channel_id": pending_channel_id}) + expected_error_message = " our signature has been sent. It cannot be abandoned" + assert expected_error_message in exc_info.value.args[0], ( + f"Expected substring '{expected_error_message}' " + f"not found in actual string '{exc_info.value.args[0]}'" + ) + time.sleep(1) + self.wait_for_channel_state( + wasmFiber.get_client(), self.fiber1.get_peer_id(), "CHANNEL_READY" + ) + + # accept_channel + # get wasm fiber peer_id + list_peers = self.fiber1.get_client().list_peers() + wasm_node_id = wasmFiber.get_client().node_info()["node_id"] + for peer in list_peers["peers"]: + if peer["pubkey"] == wasm_node_id: + wasm_fiber_peer_id = peer["peer_id"] + break + temporary_channel = self.fiber1.get_client().open_channel( + { + "peer_id": wasm_fiber_peer_id, + "funding_amount": hex(100 + 62 * 100000000), + "public": True, + } + ) + time.sleep(2) + channel = wasmFiber.get_client().accept_channel( + { + "temporary_channel_id": temporary_channel["temporary_channel_id"], + "funding_amount": hex(100 + 62 * 100000000), + } + ) + self.wait_for_channel_state( + wasmFiber.get_client(), self.fiber1.get_peer_id(), "CHANNEL_READY" + ) + # list_channels + wasm_list_channel = wasmFiber.get_client().list_channels({}) + fiber1_list_channel = self.fiber1.get_client().list_channels({}) + print("wasm_list_channel:", wasm_list_channel) + print("fiber1_list_channel:", fiber1_list_channel) + assert ( + wasm_list_channel["channels"][0]["channel_id"] + == fiber1_list_channel["channels"][0]["channel_id"] + ) + + # update_channel + update_channel_id = wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ] + wasmFiber.get_client().update_channel( + { + "channel_id": update_channel_id, + "tlc_fee_proportional_millionths": hex(2000), + } + ) + time.sleep(1) + channels = wasmFiber.get_client().list_channels({}) + assert channels["channels"][0]["tlc_fee_proportional_millionths"] == hex(2000) + + # shutdown_channel + shutdown_channel_id = wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ] + wasmFiber.get_client().shutdown_channel( + { + "channel_id": shutdown_channel_id, + "close_script": self.get_account_script(account_private), + "fee_rate": "0x3FC", + } + ) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 120) + self.Miner.miner_until_tx_committed(self.node, tx_hash) + tx_message = self.get_tx_message(tx_hash) + print("tx_message:", tx_message) + self.wait_for_channel_state( + wasmFiber.get_client(), + self.fiber1.get_peer_id(), + "CLOSED", + include_closed=True, + channel_id=shutdown_channel_id, + ) + # graph_nodes + wasm_fiber_graph_nodes = wasmFiber.get_client().graph_nodes({}) + fiber1_graph_nodes = self.fiber1.get_client().graph_nodes({}) + print("fiber1_graph_nodes:", fiber1_graph_nodes) + print("wasm_fiber_graph_nodes:", wasm_fiber_graph_nodes) + # graph_channels + wasm_fiber_graph_channels = wasmFiber.get_client().graph_channels({}) + fiber1_graph_channels = self.fiber1.get_client().graph_channels({}) + print("wasm_fiber_graph_channels:", wasm_fiber_graph_channels) + print("fiber1_graph_channels:", fiber1_graph_channels) + # node_info + node_info = wasmFiber.get_client().node_info() + print("node_info:", node_info) + # new_invoice + self.send_invoice_payment(wasmFiber, self.fiber1, 1 * 100000000, True) + + self.send_invoice_payment(self.fiber1, wasmFiber, 1, True) + # parse_invoice + invoice = self.fiber1.get_client().new_invoice( + { + "amount": hex(1), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + } + ) + wasm_parse_invoice = wasmFiber.get_client().parse_invoice( + { + "invoice": invoice["invoice_address"], + } + ) + print("invoice:", invoice) + print("wasm_parse_invoice:", wasm_parse_invoice) + # get_invoice + wasm_invoice = wasmFiber.get_client().new_invoice( + { + "amount": hex(1), + "currency": "Fibd", + "description": "test invoice generated by node2", + "expiry": "0xe10", + "final_cltv": "0x28", + "payment_preimage": self.generate_random_preimage(), + "hash_algorithm": "sha256", + } + ) + wasm_get_invoice = wasmFiber.get_client().get_invoice( + {"payment_hash": wasm_invoice["invoice"]["data"]["payment_hash"]} + ) + print("wasm_get_invoice:", wasm_get_invoice) + # cancel_invoice + wasmFiber.get_client().cancel_invoice( + {"payment_hash": wasm_get_invoice["invoice"]["data"]["payment_hash"]} + ) + wasm_get_cancel_invoice = wasmFiber.get_client().get_invoice( + {"payment_hash": wasm_invoice["invoice"]["data"]["payment_hash"]} + ) + print("wasm_get_cancel_invoice:", wasm_get_cancel_invoice) + assert wasm_get_cancel_invoice["status"] == "Cancelled" + # send_payment + self.send_payment(wasmFiber, self.fiber1, 1) + # get_payment + + # build_router + # wasmFiber.get_client().build_router({}) + channel_outpoint = wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_outpoint" + ] + router = wasmFiber.get_client().build_router( + { + "amount": hex(1 * 100000000), # 超过通道余额 + "udt_type_script": None, + "hops_info": [ + { + "pubkey": self.fiber1.get_client().node_info()["node_id"], + "channel_outpoint": channel_outpoint, + }, + ], + "final_tlc_expiry_delta": None, + } + ) + print("router:", router) + # send_payment_with_router + payment = wasmFiber.get_client().send_payment_with_router( + { + "keysend": True, + "dry_run": False, + "router": router["router_hops"], + } + ) + self.wait_payment_state(wasmFiber, payment["payment_hash"], "Success") + # connect_peer + + # disconnect_peer + wasmFiber.get_client().disconnect_peer({"peer_id": self.fiber1.get_peer_id()}) + # list_peers + time.sleep(1) + peers = wasmFiber.get_client().list_peers() + assert len(peers["peers"]) == 0 + wasmFiber.connect_peer(self.fiber1) + time.sleep(1) + peers = wasmFiber.get_client().list_peers() + assert len(peers["peers"]) == 1 + # Watchtower + # todo diff --git a/test_cases/fiber/devnet/wasm/test_wasm_watch_tower.py b/test_cases/fiber/devnet/wasm/test_wasm_watch_tower.py new file mode 100644 index 0000000..7998250 --- /dev/null +++ b/test_cases/fiber/devnet/wasm/test_wasm_watch_tower.py @@ -0,0 +1,138 @@ +import time + +import pytest + +from framework.basic_fiber import FiberTest +from framework.test_wasm_fiber import WasmFiber + + +class TestWasmWatchTower(FiberTest): + start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} + + def test_wasm_watch_tower1(self): + """ + Test the watch tower functionality in the devnet environment. + """ + # This test is a placeholder and should be implemented with actual logic. + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet-watch-tower", + # "devnet" + ) + for i in range(2): + self.open_channel( + wasmFiber, self.fiber1, 1000 * 100000000, 1000 * 100000000 + ) + for i in range(5): + self.send_payment(wasmFiber, self.fiber1, 100000) + for i in range(5): + self.send_payment(self.fiber1, wasmFiber, 100000) + + self.fiber1.stop() + wasmFiber.get_client().shutdown_channel( + { + "channel_id": wasmFiber.get_client().list_channels({})["channels"][ + 0 + ]["channel_id"], + "force": True, + } + ) + time.sleep(1) + shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx) + self.node.getClient().generate_epochs("0x1", 0) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 600) + message = self.get_tx_message(tx_hash) + print("message:", message) + # message: {'input_cells': + # 'output_cells': [{'args': '0xc8328aabcd9b9e8e64fbc566c4385c3bdeb219d7', 'capacity': 106199999545}, {'args': '0x75178f34549c5fe9cd1a0c57aebd01e7ddf9249e', 'capacity': 106199999545}, {'args': '0x470dcdc5e44064909650113a274b3b36aecb6dc7', 'capacity': 519873503699999188}], 'fee': 1267} + wasmFiberArgs = wasmFiber.get_client().node_info()[ + "default_funding_lock_script" + ]["args"] + assert ( + message["output_cells"][0]["args"] == wasmFiberArgs + or message["output_cells"][1]["args"] + ) + if message["output_cells"][0]["args"] == wasmFiberArgs: + assert ( + 1062 * 100000000 - message["output_cells"][0]["capacity"] + < 100000000 + and 1062 * 100000000 - message["output_cells"][0]["capacity"] > 0 + ) + else: + assert ( + 1062 * 100000000 - message["output_cells"][1]["capacity"] + < 100000000 + and 1062 * 100000000 - message["output_cells"][1]["capacity"] > 0 + ) + self.fiber1.start() + + @pytest.mark.skip("Musig2RoundFinalizeError") + def test_watch_tower_restart(self): + account_private = self.generate_account( + 10000, self.Config.ACCOUNT_PRIVATE_1, 10000 * 100000000 + ) + WasmFiber.reset() + wasmFiber = WasmFiber( + account_private, + "0201010101010101010101010101010101010101010101010101010101010101", + "devnet-watch-tower", + ) + + self.open_channel(wasmFiber, self.fiber1, 1000 * 100000000, 1000 * 100000000) + wasm_node_id = wasmFiber.get_client().node_info()["node_id"] + before_fiber1_balance = self.get_fiber_balance(self.fiber1) + self.fiber2.stop() + payment = self.fiber1.get_client().send_payment( + { + "target_pubkey": wasm_node_id, + "amount": hex(1 * 100000000), + "keysend": True, + "allow_self_payment": True, + } + ) + time.sleep(5) + self.wait_payment_state(self.fiber1, payment["payment_hash"], "Inflight") + self.fiber2.start() + wasmFiber.refresh() + self.wait_payment_state(self.fiber1, payment["payment_hash"], "Success") + after_fiber1_balance = self.get_fiber_balance(self.fiber1) + print("before_fiber1_balance:", before_fiber1_balance) + print("after_fiber1_balance:", after_fiber1_balance) + self.fiber1.stop() + wasmFiber.get_client().shutdown_channel( + { + "channel_id": wasmFiber.get_client().list_channels({})["channels"][0][ + "channel_id" + ], + "force": True, + } + ) + shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx) + self.node.getClient().generate_epochs("0x1", 0) + tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 600) + message = self.get_tx_message(tx_hash) + print("message:", message) + wasmFiberArgs = wasmFiber.get_client().node_info()[ + "default_funding_lock_script" + ]["args"] + assert ( + message["output_cells"][0]["args"] == wasmFiberArgs + or message["output_cells"][1]["args"] + ) + if message["output_cells"][0]["args"] == wasmFiberArgs: + assert ( + 1063 * 100000000 - message["output_cells"][0]["capacity"] < 100000000 + and 1063 * 100000000 - message["output_cells"][0]["capacity"] > 0 + ) + else: + assert ( + 1063 * 100000000 - message["output_cells"][1]["capacity"] < 100000000 + and 1063 * 100000000 - message["output_cells"][1]["capacity"] > 0 + ) diff --git a/test_cases/fiber/devnet/watch_tower/test_with_tx.py b/test_cases/fiber/devnet/watch_tower/test_with_tx.py index d79ce17..1d77516 100644 --- a/test_cases/fiber/devnet/watch_tower/test_with_tx.py +++ b/test_cases/fiber/devnet/watch_tower/test_with_tx.py @@ -7,7 +7,7 @@ class WithTx(FiberTest): - @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/503") + # @pytest.mark.skip("https://github.com/nervosnetwork/fiber/issues/503") def test_send_force_shutdown_with_tx(self): temporary_channel_id = self.fiber1.get_client().open_channel( { @@ -83,9 +83,12 @@ def test_send_force_shutdown_with_tx(self): } in message["output_cells"] # todo - payment_hash = self.send_payment(self.fiber2, self.fiber1, 1, False) - self.wait_payment_finished(self.fiber2, payment_hash, 120) - self.wait_payment_state(self.fiber2, payment_hash, "Failed") + try: + payment_hash = self.send_payment(self.fiber2, self.fiber1, 1, False) + self.wait_payment_state(self.fiber2, payment_hash, "Failed") + except Exception as e: + print(f"Expected failure when sending payment after force shutdown: {e}") + assert "no path found" in f"{e}" def test_receive_force_shutdown_with_tx(self): temporary_channel_id = self.fiber1.get_client().open_channel( diff --git a/test_cases/fiber/devnet/watch_tower_wit_tlc/test_mutil_to_one.py b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_mutil_to_one.py new file mode 100644 index 0000000..e6ba1c5 --- /dev/null +++ b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_mutil_to_one.py @@ -0,0 +1,74 @@ +import time + +from framework.basic_fiber import FiberTest + + +class TestMutilToOne(FiberTest): + start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} + + def teardown_method(self, method): + + self.restore_time() + super().teardown_method(method) + + def test_mutil_to_one(self): + """ + aN->b->c + Returns: + """ + for i in range(10): + self.start_new_fiber(self.generate_account(10000)) + fibers_balance = [] + for i in range(len(self.fibers)): + balance = self.get_fiber_balance(self.fibers[i]) + fibers_balance.append(balance) + + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 0) + for i in range(len(self.new_fibers)): + self.open_channel(self.new_fibers[i], self.fiber1, 1000 * 100000000, 0) + for i in range(10): + for j in range(len(self.new_fibers)): + self.send_payment(self.new_fibers[i], self.fiber2, 1 * 100000000, False) + self.fiber1.get_client().disconnect_peer({"peer_id": self.fiber2.get_peer_id()}) + self.add_time_and_generate_block(23, 20) + while len(self.get_commit_cells()) == 0: + self.add_time_and_generate_block(1, 20) + time.sleep(15) + while len(self.get_commit_cells()) > 0: + # cells = self.get_commit_cells() + self.add_time_and_generate_block(1, 600) + time.sleep(20) + channels = self.fiber1.get_client().list_channels({}) + for channel in channels["channels"]: + try: + self.fiber1.get_client().shutdown_channel( + { + "channel_id": channel["channel_id"], + "close_script": self.get_account_script( + self.fiber1.account_private + ), + "fee_rate": "0x3FC", + } + ) + shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 200) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx) + except Exception as e: + pass + + time.sleep(10) + after_fibers_balance = [] + for i in range(len(self.fibers)): + balance = self.get_fiber_balance(self.fibers[i]) + after_fibers_balance.append(balance) + print("---before-----") + for i in range(len(fibers_balance)): + print(fibers_balance[i]) + print("-----after-----") + for i in range(len(after_fibers_balance)): + print(after_fibers_balance[i]) + for i in range(len(after_fibers_balance)): + print( + f"fiber:{i}: before:{fibers_balance[i]['chain']['ckb']} after:{after_fibers_balance[i]['chain']['ckb']},result:{after_fibers_balance[i]['chain']['ckb'] - fibers_balance[i]['chain']['ckb']}" + ) + + # self.add_time_and_generate_block(24 - 4, 100) diff --git a/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc.py b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc.py index 48b0e71..ad034b1 100644 --- a/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc.py +++ b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc.py @@ -1,3017 +1,3022 @@ -import time - -import pytest - -from framework.basic_fiber import FiberTest -from framework.test_fiber import FiberConfigPath - - -class TestPendingTlc(FiberTest): - fiber_version = FiberConfigPath.CURRENT_DEV_DEBUG - - """ - pending tlc + watch tower,node1 force shutdown - node1 和 node2 都没有tlc - node1 有N个tlc - 在tlc过期前 - 时间过去 0～ 1/3 个 delay_epoch - node2 可以通过pre_image 解锁部分tlc - node2 无法解锁 - node1 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node2 可以通过pre_image 解锁部分tlc - node1 无法解锁 - 2/3～1 - node1无法取回 - node2 可以通过pre_image 解锁部分tlc - 时间过去 delay_epoch - node2 可以通过pre_image 解锁部分tlc - node2 可以舍弃tlc - node1 无法解锁 - 在tlc 过期后 - 时间过去 0～ 1/3 个 delay_epoch - node2 可以通过pre_image 解锁部分tlc - node1 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node2 可以通过pre_image 解锁部分tlc - node1 可以解锁 - 2/3～1 - node1无法取回 - node2 可以通过pre_image 解锁部分tlc - 时间过去 delay_epoch - node2 可以通过pre_image 解锁部分tlc - node2 可以舍弃 tlc - node1 可以解锁 - node2有N个tlc - 在tlc 过期前 - delay_epoch 过去0-1/3 - node1 可以通过pre_image解锁部分tlc - remove_tlc 会失败 可能测不了 - node2 无法解锁 - delay_epoch 1/3 -2/3 - node1 可以通过pre_image 解锁部分tlc - remove_tlc 会失败 可能测不了 - node2 无法解锁 - 2/3～1 - node2无法取回 - node1 可以通过pre_image 解锁部分tlc - >delay_epoch - node1 可以通过pre_image 解锁部分tlc - remove_tlc 会失败 可能测不了 - node2 无法解锁 - 在tlc 过期后 - delay_epoch 过去0-1/3 - node1 可以通过pre_image 解锁部分tlc - remove_tlc 会失败 可能测不了 - node2 无法解锁 - delay_epoch 1/3 -2/3 - node1 可以通过pre_image 解锁部分tlc - remove_tlc 会失败 可能测不了 - node2 可以解锁 - 2/3～1 - node2无法取回 - node1 可以通过pre_image 解锁部分tlc - >delay_epoch - node1 可以通过pre_image 解锁部分tlc - remove_tlc 会失败 可能测不了 - node1 可以舍弃tlc - node2 可以解锁 - node1和node2 都有n个tlc - 复杂的场景5,5个tlc，node2有一个能解锁的tlc - 测试N的上限 - """ - - start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} - - # debug = True - - # node1 有tlc 过期前 - - def test_node1_has_n_tlc_with_node2_opt(self): - """ - node1 有N个tlc - 在tlc过期前 - 时间过去 0～ 1/3 个 delay_epoch - node2 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node2 可以通过pre_image 解锁部分tlc - - 时间过去 delay_epoch - node2 可以舍弃tlc - - 1. node1 4个 add_tlc - 2. node2 remove_tlc - 1个tlc - 3. node1 强制shutdown - 4. node1 关闭watch tower - 5. 时间过去 0～ 1/3 个 delay_epoch - node2 不会操作 - 6. 时间过去 1/3 个delay_epoch - node2 会发送commit+ tlc - 7. 时间过去 delay epoch - node2 会遗弃 tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 8000) * 1000), - } - ) - time.sleep(2) - for i in range(3): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 200) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(4) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - except Exception: - pass - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - - # 6. 时间过去 delay_epoch 1/3 -2/3 - # node2 会 发送commit+ tlc - self.node.getClient().generate_epochs("0x2") - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) - node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) - assert ( - node2_remove_tlc_message["input_cells"][0]["capacity"] - - node2_remove_tlc_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - assert ( - node2_remove_tlc_message["output_cells"][1]["args"] - == self.account2["lock_arg"] - ) - - # 7. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) - assert status["status"] == "live" - # 9. 时间过去 delay epoch - # node2 会遗弃 tlc - self.node.getClient().generate_epochs("0x6") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - # self.Miner.miner_until_tx_committed(self.node, final_tx) - final_tx_message = self.get_tx_message(final_tx) - assert { - "args": self.account2["lock_arg"], - "capacity": 6199999545, - } in final_tx_message["output_cells"] - assert { - "args": self.account1["lock_arg"], - "capacity": 879999999545, - } in final_tx_message["output_cells"] - assert final_tx_message["fee"] > 90000000000 - - def test_node1_has_n_tlc_with_node2_2_3_epoch_opt(self): - """ - node1 有N个tlc - 在tlc过期前 - 时间过去 2/3 delay epoch - node2 可以通过pre_image 解锁部分tlc - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 8000) * 1000), - } - ) - time.sleep(2) - for i in range(3): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 200) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(4) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - except Exception: - pass - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - self.fiber2.stop() - - # 6. 时间过去 delay_epoch 2/3 - # node2 会 发送commit+ tlc - self.node.getClient().generate_epochs("0x4") - self.fiber2.start() - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) - node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) - assert ( - node2_remove_tlc_message["input_cells"][0]["capacity"] - - node2_remove_tlc_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - assert ( - node2_remove_tlc_message["output_cells"][1]["args"] - == self.account2["lock_arg"] - ) - - # 7. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) - assert status["status"] == "live" - # 9. 时间过去 delay epoch - # node2 会遗弃 tlc - self.node.getClient().generate_epochs("0x6") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - # self.Miner.miner_until_tx_committed(self.node, final_tx) - final_tx_message = self.get_tx_message(final_tx) - assert { - "args": self.account2["lock_arg"], - "capacity": 6199999545, - } in final_tx_message["output_cells"] - assert { - "args": self.account1["lock_arg"], - "capacity": 879999999545, - } in final_tx_message["output_cells"] - assert final_tx_message["fee"] > 90000000000 - - def test_node1_has_n_tlc_with_node2_epoch_opt_2(self): - """ - 在tlc过期前 - 时间过去 delay_epoch - 有能解锁的tlc ，也有不能解锁的tlc - node2 可以通过pre_image 解锁部分tlc - node2 不能 解锁的tlc 直接抛弃 - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 8000) * 1000), - } - ) - time.sleep(2) - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 200) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - - self.fiber2.stop() - # 6. 时间过去 delay_epoch 0x6 - # node2 会 发送commit+ tlc - self.node.getClient().generate_epochs("0x6") - self.fiber2.start() - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - message = self.get_tx_message(node2_remove_tlc_tx) - print(message) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - self.node.getClient().generate_epochs("0x6") - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - message = self.get_tx_message(node2_remove_tlc_tx) - print(message) - assert message["fee"] - 600 * 100000000 < 1000000 - - def test_node1_has_n_tlc_un_expired(self): - """ - node1 有N个tlc - 过期前 - 时间过去 0～ 1/3 个 delay_epoch - node1 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node1 无法解锁 - 时间过去 delay_epoch 2/3 -1 - node1 无法解锁 - 时间过去 delay_epoch - node1 遗弃tlc - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - # "commitment_delay_epoch": hex(6), - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 300) * 1000), - } - ) - time.sleep(2) - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 300) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - - self.fiber2.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 epoch - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - self.node.getClient().generate_epochs("0x2") - tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx_hash) - assert message["fee"] - 90000000000 > 0 - assert message["fee"] - 90000000000 < 100000 - - # node1 有tlc 过期后 - @pytest.mark.skip("tlc 过期后, node2 不可以通过pre_image 解锁部分tlc") - def test_node1_has_n_tlc_expired_with_node2_1_3_opt(self): - """ - node1 有N个tlc - 在tlc过期后 - 时间过去 0～ 1/3 个 delay_epoch - node2 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node2 可以通过pre_image 解锁部分tlc - 时间过去 delay_epoch - node2 可以舍弃tlc - - 1. node1 4个 add_tlc - 2. node2 remove_tlc - 1个tlc - 3. node1 强制shutdown - 4. node1 关闭watch tower - 5. 时间过去 0～ 1/3 个 delay_epoch - node2 不会操作 - 6. 时间过去 1/3 个delay_epoch - node2 会发送commit+ tlc - 7. 时间过去 delay epoch - node2 会遗弃 tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - time.sleep(2) - for i in range(3): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - except Exception: - pass - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - - # 6. 时间过去 delay_epoch 1/3 -2/3 - # node2 会 发送commit+ tlc - self.node.getClient().generate_epochs("0x2") - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) - node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) - assert ( - node2_remove_tlc_message["input_cells"][0]["capacity"] - - node2_remove_tlc_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - assert ( - node2_remove_tlc_message["output_cells"][1]["args"] - == self.account2["lock_arg"] - ) - - # 7. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) - assert status["status"] == "live" - # 9. 时间过去 delay epoch - # node2 会遗弃 tlc - self.node.getClient().generate_epochs("0x6") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - # self.Miner.miner_until_tx_committed(self.node, final_tx) - final_tx_message = self.get_tx_message(final_tx) - assert { - "args": self.account2["lock_arg"], - "capacity": 6199999545, - } in final_tx_message["output_cells"] - assert { - "args": self.account1["lock_arg"], - "capacity": 879999999545, - } in final_tx_message["output_cells"] - assert final_tx_message["fee"] > 90000000000 - - @pytest.mark.skip("tlc 过期后, node2 不可以通过pre_image 解锁部分tlc") - def test_node1_has_n_tlc_expired_with_node2_2_3_opt(self): - """ - node1 有N个tlc - 在tlc过期后 - 时间过去 delay_epoch 2/3~1 - node2 可以通过pre_image 解锁部分tlc - 时间过去 delay_epoch - node2 可以舍弃tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - time.sleep(2) - for i in range(3): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - except Exception: - pass - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 0～ 1/3 个 delay_epoch - # node2 不会操作 - time.sleep(15) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - self.fiber2.stop() - # 6. 时间过去 delay_epoch 1/3 -2/3 - # node2 会 发送commit+ tlc - self.node.getClient().generate_epochs("0x4") - self.fiber2.start() - time.sleep(15) - node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) - node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) - assert ( - node2_remove_tlc_message["input_cells"][0]["capacity"] - - node2_remove_tlc_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - assert ( - node2_remove_tlc_message["output_cells"][1]["args"] - == self.account2["lock_arg"] - ) - - def test_node1_tlc_discard_by_node2_after_delay(self): - """ - node1 有N个tlc - 在tlc过期后 - 时间过去 delay_epoch - node2 可以舍弃tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - time.sleep(2) - for i in range(3): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - time.sleep(1) - except Exception: - pass - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - time.sleep(15) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 5. 时间过去 delay_epoch - # node2 舍弃 tlc - self.fiber2.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber2.start() - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, final_tx) - final_tx_tlc_message = self.get_tx_message(final_tx) - print("final_tx_tlc_message:", final_tx_tlc_message) - assert final_tx_tlc_message["fee"] - 120000000000 > 0 - assert final_tx_tlc_message["fee"] - 120000000000 < 100000 - - def test_node1_tlc_expired_node1_opt(self): - """ - node1 有N个tlc - 在tlc过期后 - 时间过去 0～ 1/3 个 delay_epoch - node1 无法解锁 - 时间过去 delay_epoch 1/3 -2/3 - node1 无法解锁 - 时间过去 delay_epoch 2/3～1 - node1 可以解锁 - 时间过去 delay_epoch - node1 可以解锁 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - # "commitment_delay_epoch": hex(6), - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - time.sleep(2) - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - self.fiber2.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 时间过去 0～ 1/3 个 delay_epoch - # node1 无法解锁 - time.sleep(10) - # 时间过去 delay_epoch 1/3 -2/3 - # node1 无法解锁 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 时间过去 delay_epoch 2/3～1 - # node1 可以解锁 - self.node.getClient().generate_epochs("0x2") - first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, first_tx) - first_tx_message = self.get_tx_message(first_tx) - print("first_tx_message:", first_tx_message) - assert ( - first_tx_message["input_cells"][0]["capacity"] - - first_tx_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - # 时间过去 delay_epoch - # node1 可以解锁 - self.fiber1.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - next_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - next_message = self.get_tx_message(next_tx) - print("next_message :", next_message) - assert ( - next_message["input_cells"][0]["capacity"] - - next_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - self.Miner.miner_until_tx_committed(self.node, next_tx) - - # @pytest.mark.skip("如果有一个过期，一个没过期，node1 无法解锁") - def test_node1_tlc_expired_with_un_expired_node1_opt(self): - """ - 包含过期和没过期的tlc - 时间过去2/3 epoch - node1 解锁 过期tlc - 时间过去delay epoch - node1 能够解锁过期的tlc - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # "commitment_delay_epoch": hex(6), - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 50000) * 1000), - } - ) - time.sleep(2) - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - self.fiber2.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 时间过去 0～ 1/3 个 delay_epoch - # node1 无法解锁 - time.sleep(10) - # 时间过去 delay_epoch 1/3 -2/3 - # node1 无法解锁 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 时间过去 delay_epoch 2/3～1 - # node1 可以解锁 - self.node.getClient().generate_epochs("0x2") - first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, first_tx) - first_tx_message = self.get_tx_message(first_tx) - print("first_tx_message:", first_tx_message) - assert ( - first_tx_message["input_cells"][0]["capacity"] - - first_tx_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - # 时间过去 delay_epoch - # node1 可以解锁 - self.fiber1.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - next_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - next_message = self.get_tx_message(next_tx) - print("next_message :", next_message) - assert ( - next_message["input_cells"][0]["capacity"] - - next_message["output_cells"][0]["capacity"] - == 300 * 100000000 - ) - self.Miner.miner_until_tx_committed(self.node, next_tx) - - def test_node1_tlc_expired_with_un_expired_node2_opt(self): - """ - 包含过期和没过期的tlc - 时间过去1/3 epoch - - 时间过去2/3 epoch - node2 解锁 过期tlc - 时间过去delay epoch - node1 能够解锁过期的tlc - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # "commitment_delay_epoch": hex(6), - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 50000) * 1000), - } - ) - time.sleep(2) - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(300 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(300 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - # remove tlc - for i in range(1): - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 时间过去 0～ 1/3 个 delay_epoch - # node1 无法解锁 - time.sleep(10) - # 时间过去 delay_epoch 1/3 -2/3 - # node1 无法解锁 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - - # 过期前 - def test_node2_has_n_tlc_un_expired_node2_opt(self): - """ - node2 有N个tlc - 过期前 - 0～1/3 delay epoch - node2 无法处理 - 1/3～ 2/3 delay epoch - node2 不可以处理 - 2/3～1 delay epoch - node2 不可以处理 - 1 delay epoch - node2 遗弃tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(30 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 10000) * 1000), - } - ) - time.sleep(1) - for i in range(1): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(30 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 10000) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - - # remove tlc - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - self.fiber1.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - # 过期前 处理不了 - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 0～1/3 delay epoch - # node2 无法处理 - time.sleep(10) - # 1/3～ 2/3 delay epoch - # node2 不可以处理 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - # 2/3～1 delay epoch - # node2 不可以处理 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 1 delay epoch - # node2 遗弃tlc - self.node.getClient().generate_epochs("0x2") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - message = self.get_tx_message(final_tx) - assert message["fee"] - 6000000000 > 0 - assert message["fee"] - 6000000000 < 100000 - - def test_node2_has_n_tlc_un_expired_node1_opt(self): - """ - node2 有N个tlc - 过期前 - 0～1/3 delay epoch - node1 无法处理 - 1/3～ 2/3 delay epoch - node1 可以通过pre_image 解锁部分tlc - 2/3～1 delay epoch - node1 可以通过pre_image 解锁部分tlc - node1 不可以抛弃tlc - 1 delay epoch - node1 可以通过pre_image 解锁部分tlc - node1 不可以抛弃tlc - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(10000 * 100000000), - "public": True, - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(3 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 10000) * 1000), - } - ) - time.sleep(1) - for i in range(4): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(3 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(3 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 10000) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(5) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - # remove tlc - for i in range(3): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - self.fiber2.get_client().remove_watch_channel( - { - "channel_id": CHANNEL_ID, - } - ) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 0～1/3 delay epoch - # node1 无法处理 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 1/3～ 2/3 delay epoch - # node1 可以通过pre_image 解锁部分tlc - self.node.getClient().generate_epochs("0x2") - settle_tx1 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - settle_tx1_message = self.get_tx_message(settle_tx1) - print("settle_tx1_message:", settle_tx1_message) - # todo add assert - self.Miner.miner_until_tx_committed(self.node, settle_tx1) - - # 2/3～1 delay epoch - # node1 可以通过pre_image 解锁部分tlc - self.fiber1.stop() - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - settle_tx2 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - settle_tx2_message = self.get_tx_message(settle_tx2) - print("settle_tx2_message:", settle_tx2_message) - - # 1 delay epoch - # node1 可以通过pre_image 解锁部分tlc - - self.fiber1.stop() - self.Miner.miner_until_tx_committed(self.node, settle_tx2) - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - settle_tx3 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - settle_tx3_message = self.get_tx_message(settle_tx3) - print("settle_tx3_message:", settle_tx3_message) - - # 2/3～1 delay epoch - # node1 不可以抛弃tlc - self.node.getClient().generate_epochs("0x4") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), settle_tx3) - assert status["status"] == "live" - # 1 delay epoch - # node1 可以抛弃tlc - self.node.getClient().generate_epochs("0x2") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - message = self.get_tx_message(final_tx) - print("message:", message) - assert message["fee"] - 6 * 100000000 > 0 - assert message["fee"] - 6 * 100000000 < 100000 - - def test_node2_has_n_tlc_expired_node2_opt(self): - """ - node2有N个tlc - 在tlc 过期后 - 0~1/3 delay epoch - node2 无法解锁 - 1/3~2/3 delay epoch - node2 无法解锁 - 2/3~1 delay epoch - node2 可以解锁 - 1 delay epoch - node2 可以解锁 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(30 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 10) * 1000), - } - ) - time.sleep(1) - for i in range(1): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(30 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 10) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - self.fiber1.stop() - # 过期后 - # 0~1/3 delay epoch - # node2 无法解锁 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 1/3~2/3 delay epoch - # node2 无法解锁 - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 2/3~1 delay epoch - # node2 可以解锁 - self.node.getClient().generate_epochs("0x2") - first_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, first_tx) - first_tx_message = self.get_tx_message(first_tx) - print("first_tx_message:", first_tx_message) - assert ( - first_tx_message["input_cells"][0]["capacity"] - - first_tx_message["output_cells"][0]["capacity"] - == 30 * 100000000 - ) - # 1 delay epoch - # node2 可以解锁 - self.fiber2.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber2.start() - sed_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - self.Miner.miner_until_tx_committed(self.node, sed_tx) - sed_tx_message = self.get_tx_message(sed_tx) - print("sed_tx_message:", sed_tx_message) - assert ( - sed_tx_message["input_cells"][0]["capacity"] - - sed_tx_message["output_cells"][0]["capacity"] - == 30 * 100000000 - ) - - @pytest.mark.skip("如果过期,node1 解锁不了") - def test_node2_has_n_tlc_expired_node1_opt(self): - """ - node2有N个tlc - 在tlc 过期后 - 0~1/3 delay epoch - node1 无法解锁 - 1/3~2/3 delay epoch - node1 可以通过pre_image 解锁部分tlc - node1 无法解锁 没有pre_image 的tlc - 2/3~1 delay epoch - node1 可以通过pre_image 解锁部分tlc - node1 无法解锁 没有pre_image 的tlc - 1 delay epoch - node1 可以通过pre_image 解锁部分tlc - node1 可以遗弃 - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - # "funding_udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - tlcs = [] - payment_preimages = [] - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(3 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 10) * 1000), - } - ) - time.sleep(1) - for i in range(4): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(3 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(3 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 10) * 1000), - } - ) - payment_preimages.append(payment_preimage) - tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - for i in range(3): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": tlcs[i]["tlc_id"], - "reason": {"payment_preimage": payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - continue - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - self.fiber2.stop() - - # 0~1/3 delay epoch - # node1 无法解锁 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # 1/3~2/3 delay epoch - # node1 可以通过pre_image 解锁部分tlc - self.node.getClient().generate_epochs("0x2") - first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, first_tx) - first_tx_message = self.get_tx_message(first_tx) - print("first_tx_message:", first_tx_message) - assert ( - first_tx_message["input_cells"][0]["capacity"] - - first_tx_message["output_cells"][0]["capacity"] - == 3 * 100000000 - ) - # 2/3~1 delay epoch - # node1 可以通过pre_image 解锁部分tlc - self.fiber1.stop() - self.Miner.miner_until_tx_committed(self.node, first_tx) - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - sed_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - sed_tx_message = self.get_tx_message(sed_tx) - assert ( - sed_tx_message["input_cells"][0]["capacity"] - - sed_tx_message["output_cells"][0]["capacity"] - == 3 * 100000000 - ) - # 1 delay epoch - # node1 可以通过pre_image 解锁部分tlc - self.fiber1.stop() - self.Miner.miner_until_tx_committed(self.node, sed_tx) - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - thr_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - thr_tx_message = self.get_tx_message(thr_tx) - assert ( - thr_tx_message["input_cells"][0]["capacity"] - - thr_tx_message["output_cells"][0]["capacity"] - == 3 * 100000000 - ) - # 1/3~2/3 delay epoch - # node1 无法解锁 没有pre_image 的tlc - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - - # 2/3~1 delay epoch - # node1 无法解锁 没有pre_image 的tlc - self.node.getClient().generate_epochs("0x2") - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), thr_tx) - assert status["status"] == "live" - # 1 delay epoch - # node1 可以遗弃 - self.node.getClient().generate_epochs("0x2") - final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) - message = self.get_tx_message(final_tx) - print("message:", message) - assert message["fee"] - 6 * 10000000 > 0 - assert message["fee"] - 6 * 10000000 < 100000 - - # 都有tlc - # 都没过期 - def test_node1_and_node2_has_n_tlc_node1_node2(self): - """ - node1和node2 都有n个tlc - 都没过期 - 过去1/3 delay epoch - node1 解锁 - node2 解锁 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - - # # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node1_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node1_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - time.sleep(1) - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - self.node.getClient().generate_epochs("0x2") - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - self.Miner.miner_until_tx_committed(self.node, tx) - self.node.getClient().generate_epochs("0x2") - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - - def test_node1_and_node2_has_n_tlc_2_3_node1_node2(self): - """ - node1和node2 都有n个tlc - 都没过期 - 过去2/3 delay epoch - node1 解锁 - node2 解锁 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(30 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - # # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node1_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node1_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 2/3 - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - self.fiber2.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - time.sleep(5) - self.Miner.miner_until_tx_committed(self.node, tx) - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - self.fiber2.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - - def test_node1_and_node2_has_n_tlc_3_3_node1_node2(self): - """ - node1和node2 都有n个tlc - 都没过期 - 过去 delay epoch - node1 解锁 - node2 解锁 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - # # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node1_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node1_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 2/3 - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.fiber2.start() - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - time.sleep(5) - self.Miner.miner_until_tx_committed(self.node, tx) - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x6") - self.fiber2.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, tx) - self.fiber1.start() - message = self.get_tx_message(tx) - print("message:", message) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 1 * 100000000 - ) - - @pytest.mark.skip("如果2边tlc都没过期,node1和node2 都解锁不了") - def test_node1_and_node2_has_n_tlc_expired_n12(self): - """ - node1和node2 都有n个tlc - 都没过期 - 过去 delay epoch - 2个节点都解锁不了 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 700000) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - - # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node1_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node1_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - self.node.getClient().generate_epochs("0x6") - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - - @pytest.mark.skip("node1 重启会导致 2/3的时候无法解锁过期tlc") - def test_node1_and_node2_has_n_tlc_expired_node1_stop_restart_opt(self): - """ - node1和node2 都有n个tlc - 都过期了 - 过去2/3 delay epoch - node1 能解锁过期的tlc - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 5) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) - - # # remove tlc - # for i in range(1): - # try: - # self.fiber2.get_client().remove_tlc({ - # "channel_id": CHANNEL_ID, - # "tlc_id": node1_tlcs[i]["tlc_id"], - # "reason": { - # "payment_preimage": node1_payment_preimages[i] - # } - # }) - # except Exception as e: - # print(e) - # time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # self.node.getClient().generate_epochs("0x2") - # 过去2/3 delay epoch - # node1 能解锁过期的tlc - # node2 能解锁过期的tlc - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - print("message:", message) - - def test_node1_and_node2_has_n_tlc_expired_node1_stop_opt(self): - """ - node1和node2 都有n个tlc - 都过期了 - 过去2/3 delay epoch - node1 能解锁过期的tlc - Returns: - - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - time.sleep(1) - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 100000000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) - - # # remove tlc - # for i in range(1): - # try: - # self.fiber2.get_client().remove_tlc({ - # "channel_id": CHANNEL_ID, - # "tlc_id": node1_tlcs[i]["tlc_id"], - # "reason": { - # "payment_preimage": node1_payment_preimages[i] - # } - # }) - # except Exception as e: - # print(e) - # time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # self.node.getClient().generate_epochs("0x2") - # 过去2/3 delay epoch - # node1 能解锁过期的tlc - # node2 能解锁过期的tlc - self.fiber2.stop() - self.node.getClient().generate_epochs("0x4") - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - print("message:", message) - time.sleep(3) - self.Miner.miner_until_tx_committed(self.node, tx) - - def test_01_node1_and_node2_has_n_tlc_expired(self): - """ - node1和node2 都有n个tlc - 都过期了 - 过去2/3 delay epoch - node1 能解锁过期的tlc - node2 能解锁过期的tlc - 过去 delay epoch - 2个节点都能解锁 - 当自己tlc 清理完 node 会遗弃交易 - Returns: - """ - fiber3 = self.start_new_fiber(self.generate_account(1000)) - self.fiber1.get_client().open_channel( - { - "peer_id": self.fiber2.get_peer_id(), - "funding_amount": hex(1000 * 100000000), - "public": True, - } - ) - self.wait_for_channel_state( - self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" - ) - # 创建N个tlc - self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) - CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ - "channel_id" - ] - self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(92 * 100000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - time.sleep(1) - self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 110000000), - "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - time.sleep(1) - self.get_fibers_balance_message() - node1_tlcs = [] - node1_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber1.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 101000000 + i * 100000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - node1_payment_preimages.append(payment_preimage) - node1_tlcs.append(tlc) - time.sleep(2) - - node2_tlcs = [] - node2_payment_preimages = [] - for i in range(2): - payment_preimage = self.generate_random_preimage() - invoice = fiber3.get_client().new_invoice( - { - "amount": hex(1 * 100000000), - "currency": "Fibd", - "description": "test invoice generated by node3", - "expiry": "0xe10", - "final_expiry_delta": "0xDFFA0", - "payment_preimage": payment_preimage, - # "udt_type_script": self.get_account_udt_script( - # self.fiber1.account_private - # ), - } - ) - tlc = self.fiber2.get_client().add_tlc( - { - "channel_id": CHANNEL_ID, - "amount": hex(1 * 102000000 + i * 100000), - "payment_hash": invoice["invoice"]["data"]["payment_hash"], - "expiry": hex((int(time.time()) + 15) * 1000), - } - ) - node2_payment_preimages.append(payment_preimage) - node2_tlcs.append(tlc) - time.sleep(2) - # shutdown - self.get_fibers_balance_message() - self.fiber1.get_client().shutdown_channel( - { - "channel_id": CHANNEL_ID, - "force": True, - } - ) - shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) - - # # remove tlc - for i in range(1): - try: - self.fiber2.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node1_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node1_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - for i in range(1): - try: - self.fiber1.get_client().remove_tlc( - { - "channel_id": CHANNEL_ID, - "tlc_id": node2_tlcs[i]["tlc_id"], - "reason": {"payment_preimage": node2_payment_preimages[i]}, - } - ) - except Exception as e: - print(e) - time.sleep(1) - - self.Miner.miner_until_tx_committed(self.node, shutdown_tx) - # 1/3 - time.sleep(10) - status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) - assert status["status"] == "live" - # self.node.getClient().generate_epochs("0x2") - # 过去2/3 delay epoch - # node1 能解锁过期的tlc - # node2 能解锁过期的tlc - self.fiber1.stop() - self.fiber2.stop() - self.node.getClient().generate_epochs("0x4") - self.fiber1.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 110000000 - ) - print("first message:", message) - self.fiber1.stop() - self.Miner.miner_until_tx_committed(self.node, tx) - self.node.getClient().generate_epochs("0x4") - self.fiber2.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.fiber1.start() - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 101000000 - ) - print("2 message:", message) - - # 过去 delay epoch - # 2个节点都能解锁 - self.fiber1.stop() - self.fiber2.stop() - self.Miner.miner_until_tx_committed(self.node, tx) - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.fiber2.start() - message = self.get_tx_message(tx) - print("3:", message) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 101100000 - ) - self.fiber1.stop() - self.fiber2.stop() - self.Miner.miner_until_tx_committed(self.node, tx) - self.node.getClient().generate_epochs("0x6") - self.fiber2.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - self.fiber1.start() - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 9200000000 - ) - self.fiber1.stop() - self.fiber2.stop() - self.Miner.miner_until_tx_committed(self.node, tx) - time.sleep(5) - self.node.getClient().generate_epochs("0x6") - self.fiber1.start() - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert ( - message["input_cells"][0]["capacity"] - - message["output_cells"][0]["capacity"] - == 102000000 - ) - time.sleep(5) - # 当自己tlc 清理完 node 会遗弃交易 - self.Miner.miner_until_tx_committed(self.node, tx) - time.sleep(5) - self.node.getClient().generate_epochs("0x6") - tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) - message = self.get_tx_message(tx) - assert message["fee"] > 1000000 +# import time +# +# import pytest +# +# from framework.basic_fiber import FiberTest +# from framework.test_fiber import FiberConfigPath +# +# +# class TestPendingTlc(FiberTest): +# fiber_version = FiberConfigPath.CURRENT_DEV_DEBUG +# +# """ +# pending tlc + watch tower,node1 force shutdown +# node1 和 node2 都没有tlc +# node1 有N个tlc +# 在tlc过期前 +# 时间过去 0～ 1/3 个 delay_epoch +# node2 可以通过pre_image 解锁部分tlc +# node2 无法解锁 +# node1 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node2 可以通过pre_image 解锁部分tlc +# node1 无法解锁 +# 2/3～1 +# node1无法取回 +# node2 可以通过pre_image 解锁部分tlc +# 时间过去 delay_epoch +# node2 可以通过pre_image 解锁部分tlc +# node2 可以舍弃tlc +# node1 无法解锁 +# 在tlc 过期后 +# 时间过去 0～ 1/3 个 delay_epoch +# node2 可以通过pre_image 解锁部分tlc +# node1 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node2 可以通过pre_image 解锁部分tlc +# node1 可以解锁 +# 2/3～1 +# node1无法取回 +# node2 可以通过pre_image 解锁部分tlc +# 时间过去 delay_epoch +# node2 可以通过pre_image 解锁部分tlc +# node2 可以舍弃 tlc +# node1 可以解锁 +# node2有N个tlc +# 在tlc 过期前 +# delay_epoch 过去0-1/3 +# node1 可以通过pre_image解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node2 无法解锁 +# delay_epoch 1/3 -2/3 +# node1 可以通过pre_image 解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node2 无法解锁 +# 2/3～1 +# node2无法取回 +# node1 可以通过pre_image 解锁部分tlc +# >delay_epoch +# node1 可以通过pre_image 解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node2 无法解锁 +# 在tlc 过期后 +# delay_epoch 过去0-1/3 +# node1 可以通过pre_image 解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node2 无法解锁 +# delay_epoch 1/3 -2/3 +# node1 可以通过pre_image 解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node2 可以解锁 +# 2/3～1 +# node2无法取回 +# node1 可以通过pre_image 解锁部分tlc +# >delay_epoch +# node1 可以通过pre_image 解锁部分tlc +# remove_tlc 会失败 可能测不了 +# node1 可以舍弃tlc +# node2 可以解锁 +# node1和node2 都有n个tlc +# 复杂的场景5,5个tlc，node2有一个能解锁的tlc +# 测试N的上限 +# """ +# +# start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} +# +# # debug = True +# +# # node1 有tlc 过期前 +# +# def test_node1_has_n_tlc_with_node2_opt(self): +# """ +# node1 有N个tlc +# 在tlc过期前 +# 时间过去 0～ 1/3 个 delay_epoch +# node2 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node2 可以通过pre_image 解锁部分tlc +# +# 时间过去 delay_epoch +# node2 可以舍弃tlc +# +# 1. node1 4个 add_tlc +# 2. node2 remove_tlc +# 1个tlc +# 3. node1 强制shutdown +# 4. node1 关闭watch tower +# 5. 时间过去 0～ 1/3 个 delay_epoch +# node2 不会操作 +# 6. 时间过去 1/3 个delay_epoch +# node2 会发送commit+ tlc +# 7. 时间过去 delay epoch +# node2 会遗弃 tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 8000) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(3): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 200) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(4) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# except Exception: +# pass +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# +# # 6. 时间过去 delay_epoch 1/3 -2/3 +# # node2 会 发送commit+ tlc +# self.node.getClient().generate_epochs("0x2") +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) +# node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) +# assert ( +# node2_remove_tlc_message["input_cells"][0]["capacity"] +# - node2_remove_tlc_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# assert ( +# node2_remove_tlc_message["output_cells"][1]["args"] +# == self.account2["lock_arg"] +# ) +# +# # 7. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) +# assert status["status"] == "live" +# # 9. 时间过去 delay epoch +# # node2 会遗弃 tlc +# self.node.getClient().generate_epochs("0x6") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# # self.Miner.miner_until_tx_committed(self.node, final_tx) +# final_tx_message = self.get_tx_message(final_tx) +# assert { +# "args": self.account2["lock_arg"], +# "capacity": 6199999545, +# } in final_tx_message["output_cells"] +# assert { +# "args": self.account1["lock_arg"], +# "capacity": 879999999545, +# } in final_tx_message["output_cells"] +# assert final_tx_message["fee"] > 90000000000 +# +# def test_node1_has_n_tlc_with_node2_2_3_epoch_opt(self): +# """ +# node1 有N个tlc +# 在tlc过期前 +# 时间过去 2/3 delay epoch +# node2 可以通过pre_image 解锁部分tlc +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 8000) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(3): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 200) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(4) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# except Exception: +# pass +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# self.fiber2.stop() +# +# # 6. 时间过去 delay_epoch 2/3 +# # node2 会 发送commit+ tlc +# self.node.getClient().generate_epochs("0x4") +# self.fiber2.start() +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) +# node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) +# assert ( +# node2_remove_tlc_message["input_cells"][0]["capacity"] +# - node2_remove_tlc_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# assert ( +# node2_remove_tlc_message["output_cells"][1]["args"] +# == self.account2["lock_arg"] +# ) +# +# # 7. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) +# assert status["status"] == "live" +# # 9. 时间过去 delay epoch +# # node2 会遗弃 tlc +# self.node.getClient().generate_epochs("0x6") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# # self.Miner.miner_until_tx_committed(self.node, final_tx) +# final_tx_message = self.get_tx_message(final_tx) +# assert { +# "args": self.account2["lock_arg"], +# "capacity": 6199999545, +# } in final_tx_message["output_cells"] +# assert { +# "args": self.account1["lock_arg"], +# "capacity": 879999999545, +# } in final_tx_message["output_cells"] +# assert final_tx_message["fee"] > 90000000000 +# +# def test_node1_has_n_tlc_with_node2_epoch_opt_2(self): +# """ +# 在tlc过期前 +# 时间过去 delay_epoch +# 有能解锁的tlc ，也有不能解锁的tlc +# node2 可以通过pre_image 解锁部分tlc +# node2 不能 解锁的tlc 直接抛弃 +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 8000) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 200) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# +# self.fiber2.stop() +# # 6. 时间过去 delay_epoch 0x6 +# # node2 会 发送commit+ tlc +# self.node.getClient().generate_epochs("0x6") +# self.fiber2.start() +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# message = self.get_tx_message(node2_remove_tlc_tx) +# print(message) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# self.node.getClient().generate_epochs("0x6") +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# message = self.get_tx_message(node2_remove_tlc_tx) +# print(message) +# assert message["fee"] - 600 * 100000000 < 1000000 +# +# def test_node1_has_n_tlc_un_expired(self): +# """ +# node1 有N个tlc +# 过期前 +# 时间过去 0～ 1/3 个 delay_epoch +# node1 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node1 无法解锁 +# 时间过去 delay_epoch 2/3 -1 +# node1 无法解锁 +# 时间过去 delay_epoch +# node1 遗弃tlc +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# # "commitment_delay_epoch": hex(6), +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 300) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 300) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# +# self.fiber2.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 epoch +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# self.node.getClient().generate_epochs("0x2") +# tx_hash = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx_hash) +# assert message["fee"] - 90000000000 > 0 +# assert message["fee"] - 90000000000 < 100000 +# +# # node1 有tlc 过期后 +# @pytest.mark.skip("tlc 过期后, node2 不可以通过pre_image 解锁部分tlc") +# def test_node1_has_n_tlc_expired_with_node2_1_3_opt(self): +# """ +# node1 有N个tlc +# 在tlc过期后 +# 时间过去 0～ 1/3 个 delay_epoch +# node2 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node2 可以通过pre_image 解锁部分tlc +# 时间过去 delay_epoch +# node2 可以舍弃tlc +# +# 1. node1 4个 add_tlc +# 2. node2 remove_tlc +# 1个tlc +# 3. node1 强制shutdown +# 4. node1 关闭watch tower +# 5. 时间过去 0～ 1/3 个 delay_epoch +# node2 不会操作 +# 6. 时间过去 1/3 个delay_epoch +# node2 会发送commit+ tlc +# 7. 时间过去 delay epoch +# node2 会遗弃 tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(3): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# except Exception: +# pass +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# +# # 6. 时间过去 delay_epoch 1/3 -2/3 +# # node2 会 发送commit+ tlc +# self.node.getClient().generate_epochs("0x2") +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) +# node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) +# assert ( +# node2_remove_tlc_message["input_cells"][0]["capacity"] +# - node2_remove_tlc_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# assert ( +# node2_remove_tlc_message["output_cells"][1]["args"] +# == self.account2["lock_arg"] +# ) +# +# # 7. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), node2_remove_tlc_tx) +# assert status["status"] == "live" +# # 9. 时间过去 delay epoch +# # node2 会遗弃 tlc +# self.node.getClient().generate_epochs("0x6") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# # self.Miner.miner_until_tx_committed(self.node, final_tx) +# final_tx_message = self.get_tx_message(final_tx) +# assert { +# "args": self.account2["lock_arg"], +# "capacity": 6199999545, +# } in final_tx_message["output_cells"] +# assert { +# "args": self.account1["lock_arg"], +# "capacity": 879999999545, +# } in final_tx_message["output_cells"] +# assert final_tx_message["fee"] > 90000000000 +# +# @pytest.mark.skip("tlc 过期后, node2 不可以通过pre_image 解锁部分tlc") +# def test_node1_has_n_tlc_expired_with_node2_2_3_opt(self): +# """ +# node1 有N个tlc +# 在tlc过期后 +# 时间过去 delay_epoch 2/3~1 +# node2 可以通过pre_image 解锁部分tlc +# 时间过去 delay_epoch +# node2 可以舍弃tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(3): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# except Exception: +# pass +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 0～ 1/3 个 delay_epoch +# # node2 不会操作 +# time.sleep(15) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# self.fiber2.stop() +# # 6. 时间过去 delay_epoch 1/3 -2/3 +# # node2 会 发送commit+ tlc +# self.node.getClient().generate_epochs("0x4") +# self.fiber2.start() +# time.sleep(15) +# node2_remove_tlc_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, node2_remove_tlc_tx) +# node2_remove_tlc_message = self.get_tx_message(node2_remove_tlc_tx) +# assert ( +# node2_remove_tlc_message["input_cells"][0]["capacity"] +# - node2_remove_tlc_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# assert ( +# node2_remove_tlc_message["output_cells"][1]["args"] +# == self.account2["lock_arg"] +# ) +# +# def test_node1_tlc_discard_by_node2_after_delay(self): +# """ +# node1 有N个tlc +# 在tlc过期后 +# 时间过去 delay_epoch +# node2 可以舍弃tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(3): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# time.sleep(1) +# except Exception: +# pass +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# time.sleep(15) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 5. 时间过去 delay_epoch +# # node2 舍弃 tlc +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber2.start() +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, final_tx) +# final_tx_tlc_message = self.get_tx_message(final_tx) +# print("final_tx_tlc_message:", final_tx_tlc_message) +# assert final_tx_tlc_message["fee"] - 120000000000 > 0 +# assert final_tx_tlc_message["fee"] - 120000000000 < 100000 +# +# def test_node1_tlc_expired_node1_opt(self): +# """ +# node1 有N个tlc +# 在tlc过期后 +# 时间过去 0～ 1/3 个 delay_epoch +# node1 无法解锁 +# 时间过去 delay_epoch 1/3 -2/3 +# node1 无法解锁 +# 时间过去 delay_epoch 2/3～1 +# node1 可以解锁 +# 时间过去 delay_epoch +# node1 可以解锁 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# # "commitment_delay_epoch": hex(6), +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# self.fiber2.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 时间过去 0～ 1/3 个 delay_epoch +# # node1 无法解锁 +# time.sleep(10) +# # 时间过去 delay_epoch 1/3 -2/3 +# # node1 无法解锁 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 时间过去 delay_epoch 2/3～1 +# # node1 可以解锁 +# self.node.getClient().generate_epochs("0x2") +# first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, first_tx) +# first_tx_message = self.get_tx_message(first_tx) +# print("first_tx_message:", first_tx_message) +# assert ( +# first_tx_message["input_cells"][0]["capacity"] +# - first_tx_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# # 时间过去 delay_epoch +# # node1 可以解锁 +# self.fiber1.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# next_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# next_message = self.get_tx_message(next_tx) +# print("next_message :", next_message) +# assert ( +# next_message["input_cells"][0]["capacity"] +# - next_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# self.Miner.miner_until_tx_committed(self.node, next_tx) +# +# # @pytest.mark.skip("如果有一个过期，一个没过期，node1 无法解锁") +# def test_node1_tlc_expired_with_un_expired_node1_opt(self): +# """ +# 包含过期和没过期的tlc +# 时间过去2/3 epoch +# node1 解锁 过期tlc +# 时间过去delay epoch +# node1 能够解锁过期的tlc +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # "commitment_delay_epoch": hex(6), +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 50000) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# self.fiber2.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 时间过去 0～ 1/3 个 delay_epoch +# # node1 无法解锁 +# time.sleep(10) +# # 时间过去 delay_epoch 1/3 -2/3 +# # node1 无法解锁 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 时间过去 delay_epoch 2/3～1 +# # node1 可以解锁 +# self.node.getClient().generate_epochs("0x2") +# first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, first_tx) +# first_tx_message = self.get_tx_message(first_tx) +# print("first_tx_message:", first_tx_message) +# assert ( +# first_tx_message["input_cells"][0]["capacity"] +# - first_tx_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# # 时间过去 delay_epoch +# # node1 可以解锁 +# self.fiber1.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# next_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# next_message = self.get_tx_message(next_tx) +# print("next_message :", next_message) +# assert ( +# next_message["input_cells"][0]["capacity"] +# - next_message["output_cells"][0]["capacity"] +# == 300 * 100000000 +# ) +# self.Miner.miner_until_tx_committed(self.node, next_tx) +# +# def test_node1_tlc_expired_with_un_expired_node2_opt(self): +# """ +# 包含过期和没过期的tlc +# 时间过去1/3 epoch +# +# 时间过去2/3 epoch +# node2 解锁 过期tlc +# 时间过去delay epoch +# node1 能够解锁过期的tlc +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # "commitment_delay_epoch": hex(6), +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 50000) * 1000), +# } +# ) +# time.sleep(2) +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(300 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(300 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# # remove tlc +# for i in range(1): +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 时间过去 0～ 1/3 个 delay_epoch +# # node1 无法解锁 +# time.sleep(10) +# # 时间过去 delay_epoch 1/3 -2/3 +# # node1 无法解锁 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# +# # 过期前 +# def test_node2_has_n_tlc_un_expired_node2_opt(self): +# """ +# node2 有N个tlc +# 过期前 +# 0～1/3 delay epoch +# node2 无法处理 +# 1/3～ 2/3 delay epoch +# node2 不可以处理 +# 2/3～1 delay epoch +# node2 不可以处理 +# 1 delay epoch +# node2 遗弃tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(30 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 10000) * 1000), +# } +# ) +# time.sleep(1) +# for i in range(1): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(30 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 10000) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# +# # remove tlc +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# self.fiber1.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# # 过期前 处理不了 +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 0～1/3 delay epoch +# # node2 无法处理 +# time.sleep(10) +# # 1/3～ 2/3 delay epoch +# # node2 不可以处理 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# # 2/3～1 delay epoch +# # node2 不可以处理 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 1 delay epoch +# # node2 遗弃tlc +# self.node.getClient().generate_epochs("0x2") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# message = self.get_tx_message(final_tx) +# assert message["fee"] - 6000000000 > 0 +# assert message["fee"] - 6000000000 < 100000 +# +# def test_node2_has_n_tlc_un_expired_node1_opt(self): +# """ +# node2 有N个tlc +# 过期前 +# 0～1/3 delay epoch +# node1 无法处理 +# 1/3～ 2/3 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# 2/3～1 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# node1 不可以抛弃tlc +# 1 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# node1 不可以抛弃tlc +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(10000 * 100000000), +# "public": True, +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(3 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 10000) * 1000), +# } +# ) +# time.sleep(1) +# for i in range(4): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(3 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(3 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 10000) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(5) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# # remove tlc +# for i in range(3): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# self.fiber2.get_client().remove_watch_channel( +# { +# "channel_id": CHANNEL_ID, +# } +# ) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 0～1/3 delay epoch +# # node1 无法处理 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 1/3～ 2/3 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# self.node.getClient().generate_epochs("0x2") +# settle_tx1 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# settle_tx1_message = self.get_tx_message(settle_tx1) +# print("settle_tx1_message:", settle_tx1_message) +# # todo add assert +# self.Miner.miner_until_tx_committed(self.node, settle_tx1) +# +# # 2/3～1 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# self.fiber1.stop() +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# settle_tx2 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# settle_tx2_message = self.get_tx_message(settle_tx2) +# print("settle_tx2_message:", settle_tx2_message) +# +# # 1 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# +# self.fiber1.stop() +# self.Miner.miner_until_tx_committed(self.node, settle_tx2) +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# settle_tx3 = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# settle_tx3_message = self.get_tx_message(settle_tx3) +# print("settle_tx3_message:", settle_tx3_message) +# +# # 2/3～1 delay epoch +# # node1 不可以抛弃tlc +# self.node.getClient().generate_epochs("0x4") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), settle_tx3) +# assert status["status"] == "live" +# # 1 delay epoch +# # node1 可以抛弃tlc +# self.node.getClient().generate_epochs("0x2") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# message = self.get_tx_message(final_tx) +# print("message:", message) +# assert message["fee"] - 6 * 100000000 > 0 +# assert message["fee"] - 6 * 100000000 < 100000 +# +# def test_node2_has_n_tlc_expired_node2_opt(self): +# """ +# node2有N个tlc +# 在tlc 过期后 +# 0~1/3 delay epoch +# node2 无法解锁 +# 1/3~2/3 delay epoch +# node2 无法解锁 +# 2/3~1 delay epoch +# node2 可以解锁 +# 1 delay epoch +# node2 可以解锁 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(30 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 10) * 1000), +# } +# ) +# time.sleep(1) +# for i in range(1): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(30 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 10) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# self.fiber1.stop() +# # 过期后 +# # 0~1/3 delay epoch +# # node2 无法解锁 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 1/3~2/3 delay epoch +# # node2 无法解锁 +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 2/3~1 delay epoch +# # node2 可以解锁 +# self.node.getClient().generate_epochs("0x2") +# first_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, first_tx) +# first_tx_message = self.get_tx_message(first_tx) +# print("first_tx_message:", first_tx_message) +# assert ( +# first_tx_message["input_cells"][0]["capacity"] +# - first_tx_message["output_cells"][0]["capacity"] +# == 30 * 100000000 +# ) +# # 1 delay epoch +# # node2 可以解锁 +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber2.start() +# sed_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# self.Miner.miner_until_tx_committed(self.node, sed_tx) +# sed_tx_message = self.get_tx_message(sed_tx) +# print("sed_tx_message:", sed_tx_message) +# assert ( +# sed_tx_message["input_cells"][0]["capacity"] +# - sed_tx_message["output_cells"][0]["capacity"] +# == 30 * 100000000 +# ) +# +# @pytest.mark.skip("如果过期,node1 解锁不了") +# def test_node2_has_n_tlc_expired_node1_opt(self): +# """ +# node2有N个tlc +# 在tlc 过期后 +# 0~1/3 delay epoch +# node1 无法解锁 +# 1/3~2/3 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# node1 无法解锁 没有pre_image 的tlc +# 2/3~1 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# node1 无法解锁 没有pre_image 的tlc +# 1 delay epoch +# node1 可以通过pre_image 解锁部分tlc +# node1 可以遗弃 +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# # "funding_udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# tlcs = [] +# payment_preimages = [] +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(3 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 10) * 1000), +# } +# ) +# time.sleep(1) +# for i in range(4): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(3 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(3 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 10) * 1000), +# } +# ) +# payment_preimages.append(payment_preimage) +# tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# for i in range(3): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# continue +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# self.fiber2.stop() +# +# # 0~1/3 delay epoch +# # node1 无法解锁 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # 1/3~2/3 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# self.node.getClient().generate_epochs("0x2") +# first_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, first_tx) +# first_tx_message = self.get_tx_message(first_tx) +# print("first_tx_message:", first_tx_message) +# assert ( +# first_tx_message["input_cells"][0]["capacity"] +# - first_tx_message["output_cells"][0]["capacity"] +# == 3 * 100000000 +# ) +# # 2/3~1 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# self.fiber1.stop() +# self.Miner.miner_until_tx_committed(self.node, first_tx) +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# sed_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# sed_tx_message = self.get_tx_message(sed_tx) +# assert ( +# sed_tx_message["input_cells"][0]["capacity"] +# - sed_tx_message["output_cells"][0]["capacity"] +# == 3 * 100000000 +# ) +# # 1 delay epoch +# # node1 可以通过pre_image 解锁部分tlc +# self.fiber1.stop() +# self.Miner.miner_until_tx_committed(self.node, sed_tx) +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# thr_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# thr_tx_message = self.get_tx_message(thr_tx) +# assert ( +# thr_tx_message["input_cells"][0]["capacity"] +# - thr_tx_message["output_cells"][0]["capacity"] +# == 3 * 100000000 +# ) +# # 1/3~2/3 delay epoch +# # node1 无法解锁 没有pre_image 的tlc +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# +# # 2/3~1 delay epoch +# # node1 无法解锁 没有pre_image 的tlc +# self.node.getClient().generate_epochs("0x2") +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), thr_tx) +# assert status["status"] == "live" +# # 1 delay epoch +# # node1 可以遗弃 +# self.node.getClient().generate_epochs("0x2") +# final_tx = self.wait_and_check_tx_pool_fee(1000, False, 300) +# message = self.get_tx_message(final_tx) +# print("message:", message) +# assert message["fee"] - 6 * 10000000 > 0 +# assert message["fee"] - 6 * 10000000 < 100000 +# +# # 都有tlc +# # 都没过期 +# @pytest.mark.skip("final_expiry_delta must be greater than or equal to 57600000") +# def test_node1_and_node2_has_n_tlc_node1_node2(self): +# """ +# node1和node2 都有n个tlc +# 都没过期 +# 过去1/3 delay epoch +# node1 解锁 +# node2 解锁 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# +# # # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node1_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node1_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# time.sleep(1) +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# self.node.getClient().generate_epochs("0x2") +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.node.getClient().generate_epochs("0x2") +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# +# @pytest.mark.skip("final_expiry_delta must be greater than or equal to 57600000") +# def test_node1_and_node2_has_n_tlc_2_3_node1_node2(self): +# """ +# node1和node2 都有n个tlc +# 都没过期 +# 过去2/3 delay epoch +# node1 解锁 +# node2 解锁 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(30 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# # # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node1_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node1_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 2/3 +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# self.fiber2.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# time.sleep(5) +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# self.fiber2.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# +# @pytest.mark.skip("final_expiry_delta must be greater than or equal to 57600000") +# def test_node1_and_node2_has_n_tlc_3_3_node1_node2(self): +# """ +# node1和node2 都有n个tlc +# 都没过期 +# 过去 delay epoch +# node1 解锁 +# node2 解锁 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# # # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node1_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node1_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 2/3 +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.fiber2.start() +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# time.sleep(5) +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x6") +# self.fiber2.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.fiber1.start() +# message = self.get_tx_message(tx) +# print("message:", message) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 1 * 100000000 +# ) +# +# @pytest.mark.skip("如果2边tlc都没过期,node1和node2 都解锁不了") +# def test_node1_and_node2_has_n_tlc_expired_n12(self): +# """ +# node1和node2 都有n个tlc +# 都没过期 +# 过去 delay epoch +# 2个节点都解锁不了 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 700000) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# +# # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node1_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node1_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# self.node.getClient().generate_epochs("0x6") +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# +# @pytest.mark.skip("node1 重启会导致 2/3的时候无法解锁过期tlc") +# def test_node1_and_node2_has_n_tlc_expired_node1_stop_restart_opt(self): +# """ +# node1和node2 都有n个tlc +# 都过期了 +# 过去2/3 delay epoch +# node1 能解锁过期的tlc +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 5) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) +# +# # # remove tlc +# # for i in range(1): +# # try: +# # self.fiber2.get_client().remove_tlc({ +# # "channel_id": CHANNEL_ID, +# # "tlc_id": node1_tlcs[i]["tlc_id"], +# # "reason": { +# # "payment_preimage": node1_payment_preimages[i] +# # } +# # }) +# # except Exception as e: +# # print(e) +# # time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # self.node.getClient().generate_epochs("0x2") +# # 过去2/3 delay epoch +# # node1 能解锁过期的tlc +# # node2 能解锁过期的tlc +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# print("message:", message) +# +# @pytest.mark.skip("final_expiry_delta must be greater than or equal to 57600000") +# def test_node1_and_node2_has_n_tlc_expired_node1_stop_opt(self): +# """ +# node1和node2 都有n个tlc +# 都过期了 +# 过去2/3 delay epoch +# node1 能解锁过期的tlc +# Returns: +# +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# time.sleep(1) +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 100000000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) +# +# # # remove tlc +# # for i in range(1): +# # try: +# # self.fiber2.get_client().remove_tlc({ +# # "channel_id": CHANNEL_ID, +# # "tlc_id": node1_tlcs[i]["tlc_id"], +# # "reason": { +# # "payment_preimage": node1_payment_preimages[i] +# # } +# # }) +# # except Exception as e: +# # print(e) +# # time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # self.node.getClient().generate_epochs("0x2") +# # 过去2/3 delay epoch +# # node1 能解锁过期的tlc +# # node2 能解锁过期的tlc +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x4") +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# print("message:", message) +# time.sleep(3) +# self.Miner.miner_until_tx_committed(self.node, tx) +# +# @pytest.mark.skip("final_expiry_delta must be greater than or equal to 57600000") +# def test_01_node1_and_node2_has_n_tlc_expired(self): +# """ +# node1和node2 都有n个tlc +# 都过期了 +# 过去2/3 delay epoch +# node1 能解锁过期的tlc +# node2 能解锁过期的tlc +# 过去 delay epoch +# 2个节点都能解锁 +# 当自己tlc 清理完 node 会遗弃交易 +# Returns: +# """ +# fiber3 = self.start_new_fiber(self.generate_account(1000)) +# self.fiber1.get_client().open_channel( +# { +# "peer_id": self.fiber2.get_peer_id(), +# "funding_amount": hex(1000 * 100000000), +# "public": True, +# } +# ) +# self.wait_for_channel_state( +# self.fiber1.get_client(), self.fiber2.get_peer_id(), "CHANNEL_READY" +# ) +# # 创建N个tlc +# self.send_payment(self.fiber1, self.fiber2, 100 * 100000000) +# CHANNEL_ID = self.fiber1.get_client().list_channels({})["channels"][0][ +# "channel_id" +# ] +# self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(92 * 100000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000000", +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# time.sleep(1) +# self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 110000000), +# "payment_hash": "0x0000000000000000000000000000000000000000000000000000000000000001", +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# time.sleep(1) +# self.get_fibers_balance_message() +# node1_tlcs = [] +# node1_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber1.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 101000000 + i * 100000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# node1_payment_preimages.append(payment_preimage) +# node1_tlcs.append(tlc) +# time.sleep(2) +# +# node2_tlcs = [] +# node2_payment_preimages = [] +# for i in range(2): +# payment_preimage = self.generate_random_preimage() +# invoice = fiber3.get_client().new_invoice( +# { +# "amount": hex(1 * 100000000), +# "currency": "Fibd", +# "description": "test invoice generated by node3", +# "expiry": "0xe10", +# "final_expiry_delta": "0xDFFA0", +# "payment_preimage": payment_preimage, +# # "udt_type_script": self.get_account_udt_script( +# # self.fiber1.account_private +# # ), +# } +# ) +# tlc = self.fiber2.get_client().add_tlc( +# { +# "channel_id": CHANNEL_ID, +# "amount": hex(1 * 102000000 + i * 100000), +# "payment_hash": invoice["invoice"]["data"]["payment_hash"], +# "expiry": hex((int(time.time()) + 15) * 1000), +# } +# ) +# node2_payment_preimages.append(payment_preimage) +# node2_tlcs.append(tlc) +# time.sleep(2) +# # shutdown +# self.get_fibers_balance_message() +# self.fiber1.get_client().shutdown_channel( +# { +# "channel_id": CHANNEL_ID, +# "force": True, +# } +# ) +# shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 220) +# +# # # remove tlc +# for i in range(1): +# try: +# self.fiber2.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node1_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node1_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# for i in range(1): +# try: +# self.fiber1.get_client().remove_tlc( +# { +# "channel_id": CHANNEL_ID, +# "tlc_id": node2_tlcs[i]["tlc_id"], +# "reason": {"payment_preimage": node2_payment_preimages[i]}, +# } +# ) +# except Exception as e: +# print(e) +# time.sleep(1) +# +# self.Miner.miner_until_tx_committed(self.node, shutdown_tx) +# # 1/3 +# time.sleep(10) +# status = self.node.getClient().get_live_cell(hex(0), shutdown_tx) +# assert status["status"] == "live" +# # self.node.getClient().generate_epochs("0x2") +# # 过去2/3 delay epoch +# # node1 能解锁过期的tlc +# # node2 能解锁过期的tlc +# self.fiber1.stop() +# self.fiber2.stop() +# self.node.getClient().generate_epochs("0x4") +# self.fiber1.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 110000000 +# ) +# print("first message:", message) +# self.fiber1.stop() +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.node.getClient().generate_epochs("0x4") +# self.fiber2.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.fiber1.start() +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 101000000 +# ) +# print("2 message:", message) +# +# # 过去 delay epoch +# # 2个节点都能解锁 +# self.fiber1.stop() +# self.fiber2.stop() +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.fiber2.start() +# message = self.get_tx_message(tx) +# print("3:", message) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 101100000 +# ) +# self.fiber1.stop() +# self.fiber2.stop() +# self.Miner.miner_until_tx_committed(self.node, tx) +# self.node.getClient().generate_epochs("0x6") +# self.fiber2.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# self.fiber1.start() +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 9200000000 +# ) +# self.fiber1.stop() +# self.fiber2.stop() +# self.Miner.miner_until_tx_committed(self.node, tx) +# time.sleep(5) +# self.node.getClient().generate_epochs("0x6") +# self.fiber1.start() +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert ( +# message["input_cells"][0]["capacity"] +# - message["output_cells"][0]["capacity"] +# == 102000000 +# ) +# time.sleep(5) +# # 当自己tlc 清理完 node 会遗弃交易 +# self.Miner.miner_until_tx_committed(self.node, tx) +# time.sleep(5) +# self.node.getClient().generate_epochs("0x6") +# tx = self.wait_and_check_tx_pool_fee(1000, False, 5 * 120) +# message = self.get_tx_message(tx) +# assert message["fee"] > 1000000 diff --git a/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_2.py b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_2.py new file mode 100644 index 0000000..14744de --- /dev/null +++ b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_2.py @@ -0,0 +1,117 @@ +import time + +from framework.basic_fiber import FiberTest + + +class TestPendingTLC2(FiberTest): + # debug = True + start_fiber_config = {"fiber_watchtower_check_interval_seconds": 5} + + def teardown_method(self, method): + self.restore_time() + super().teardown_method(method) + + def test_pending_tlc_2(self): + """ + a->b->c + Returns: + + """ + self.fiber3 = self.start_new_fiber(self.generate_account(10000)) + fibers_balance = [] + for i in range(len(self.fibers)): + balance = self.get_fiber_balance(self.fibers[i]) + fibers_balance.append(balance) + + self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1) + self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 1) + for i in range(10): + self.send_payment(self.fiber1, self.fiber3, 1 * 100000000, False) + + self.fiber1.get_client().disconnect_peer({"peer_id": self.fiber2.get_peer_id()}) + # time.sleep(10) + + # 确认fiber1 和fiber2 状态一致 + fiber1_channels = self.fiber1.get_client().list_channels( + {"peer_id": self.fiber2.get_peer_id()} + ) + fiber2_channels = self.fiber2.get_client().list_channels( + {"peer_id": self.fiber1.get_peer_id()} + ) + fiber3_channels = self.fiber3.get_client().list_channels({}) + # assert fiber1_channels['channels'][0]['local_balance'] == fiber2_channels['channels'][0]['remote_balance'] + tlc_size = int( + int(fiber1_channels["channels"][0]["offered_tlc_balance"], 16) / 100100000 + ) + fiber3_pre_image_size = int( + int(fiber3_channels["channels"][0]["local_balance"], 16) / 100000000 + ) + # 时间加速48 h 直到 fiber1 自动发送强制shutdown + self.add_time_and_generate_block(48, 5) + # 生成 等待强制shutdown 交易上链 + shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 200) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx) + for i in range(len(fibers_balance)): + print(fibers_balance[i]) + while len(self.get_commit_cells()) > 0: + # cells = self.get_commit_cells() + self.add_time_and_generate_block(1, 600) + time.sleep(20) + + channels = self.fiber2.get_client().list_channels({}) + for channel in channels["channels"]: + try: + self.fiber2.get_client().shutdown_channel( + { + "channel_id": channel["channel_id"], + "close_script": self.get_account_script( + self.fiber2.account_private + ), + "fee_rate": "0x3FC", + } + ) + shutdown_tx = self.wait_and_check_tx_pool_fee(1000, False, 200) + self.Miner.miner_until_tx_committed(self.node, shutdown_tx) + except Exception as e: + pass + after_fibers_balance = [] + for i in range(len(self.fibers)): + balance = self.get_fiber_balance(self.fibers[i]) + after_fibers_balance.append(balance) + print("---before-----") + for i in range(len(fibers_balance)): + print(fibers_balance[i]) + print("-----after-----") + for i in range(len(after_fibers_balance)): + print(after_fibers_balance[i]) + for i in range(len(after_fibers_balance)): + print( + f"fiber:{i}: before:{fibers_balance[i]['chain']['ckb']} after:{after_fibers_balance[i]['chain']['ckb']},result:{after_fibers_balance[i]['chain']['ckb'] - fibers_balance[i]['chain']['ckb']}" + ) + + # + # + # def test_0000(self): + # while len(self.get_commit_cells()) > 0: + # # cells = self.get_commit_cells() + # self.add_time_and_generate_block(1, 600) + # time.sleep(20) + # + # def test_shutdown(self): + # channels = self.fiber2.get_client().list_channels({}) + # for channel in channels['channels']: + # self.fiber2.get_client().shutdown_channel({ + # "channel_id": channel['channel_id'], + # "close_script": self.get_account_script(self.fiber2.account_private), + # "fee_rate": "0x3FC", + # }) + # + # def test_0001(self): + # self.start_new_mock_fiber("") + # fibers_balance = [] + # for i in range(len(self.fibers)): + # balance = self.get_fiber_balance(self.fibers[i]) + # fibers_balance.append(balance) + # for i in range(len(fibers_balance)): + # print(fibers_balance[i]) + # diff --git a/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_3.py b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_3.py new file mode 100644 index 0000000..8ddc044 --- /dev/null +++ b/test_cases/fiber/devnet/watch_tower_wit_tlc/test_pending_tlc_3.py @@ -0,0 +1,46 @@ +# import time +# +# from framework.basic_fiber import FiberTest +# +# +# class TestPendingTLC3(FiberTest): +# debug = True +# +# def test_pending_tlc_3(self): +# for i in range(20): +# self.start_new_fiber(self.generate_account(10000)) +# self.fiber3 = self.start_new_fiber(self.generate_account(10000)) +# self.open_channel(self.fiber2, self.fiber3, 1000 * 100000000, 1000 * 100000000) +# self.open_channel(self.fiber1, self.fiber2, 1000 * 100000000, 1000 * 100000000) +# for i in range(len(self.new_fibers)-1): +# self.open_channel(self.new_fibers[i], self.fiber1, 1000 * 100000000, 1000 * 100000000) +# for i in range(len(self.new_fibers)-1): +# for i in range(20): +# try: +# self.send_payment(self.new_fibers[i], self.fiber3, 1 * 100000000,False,try_count=0) +# except Exception as e: +# pass +# self.fiber1.get_client().disconnect_peer({ +# "peer_id": self.fiber2.get_peer_id() +# }) +# +# def test_01000(self): +# for i in range(21): +# self.start_new_fiber("") +# self.get_fiber_graph_balance() +# # self.send_payment(self.fibers[0], self.fibers[-1], 1 * 100000000, False) +# +# def test_add_time(self): +# for i in range(400): +# self.add_time_and_generate_block(2,900) +# time.sleep(90) +# +# def test_00000(self): +# cells = self.get_commit_cells() +# print(len(cells)) +# self.node.getClient().get_live_cell("0x0","0x135f65dbc5617dff4cce5e8e427ff77e39d77ecc2680d71dab885cbe2d436923") +# +# def test_ba(self): +# for i in range(3): +# self.start_new_fiber("") +# self.get_fiber_graph_balance()