diff --git a/deps/k_release b/deps/k_release index 9816449..d0919bd 100644 --- a/deps/k_release +++ b/deps/k_release @@ -1 +1 @@ -7.1.319 +7.1.337 diff --git a/docs/node-semantics.md b/docs/node-semantics.md index e55c9d5..83a713d 100644 --- a/docs/node-semantics.md +++ b/docs/node-semantics.md @@ -140,7 +140,7 @@ Step decoding pattern-matches on the `JSON` sort. Key order in the step objects #decodeStep({ "op": "callTx", ... })→ callTx(...) ``` -SCVal arguments are decoded by `#decodeArg`, which matches on `"type"` and produces a K `ScVal` constructor (`SCBool`, `I32`, `U32`, `I64`, `U64`, `I128`, `U128`, `Symbol`, `ScBytes`, `ScAddress`). +SCVal arguments are decoded by `#decodeArg`, which matches on `"type"` and produces a K `ScVal` constructor (`Void`, `SCBool`, `I32`, `U32`, `I64`, `U64`, `I128`, `U128`, `I256`, `U256`, `Symbol`, `ScString`, `ScBytes`, `ScAddress`, `ScVec`, `ScMap`) — the same set `scval_to_json` encodes, so the two stay in step. The `steps-done` rule (mirroring KASMER's `steps-empty` but with a `...` frame) consumes the final `.Steps` so the `#finalizeTx` continuation can proceed. diff --git a/flake.lock b/flake.lock index 7ed0082..a91f721 100644 --- a/flake.lock +++ b/flake.lock @@ -84,16 +84,16 @@ "z3": "z3" }, "locked": { - "lastModified": 1769721341, - "narHash": "sha256-tHHaCWhdBXAeIeOoRqwLke+PkfYflFD9wH7a4Q+iCis=", + "lastModified": 1781757330, + "narHash": "sha256-bUd4OrjJ3cMXhMkSN21tAG3ShgwCGR9j1SW1GsK0YrA=", "owner": "runtimeverification", "repo": "haskell-backend", - "rev": "bf7eaa523d856ac0c0fe72109cb35034338b885b", + "rev": "38afc81fc9414f1e11e609b01a43a436b613bd2d", "type": "github" }, "original": { "owner": "runtimeverification", - "ref": "v0.1.145", + "ref": "v0.1.155", "repo": "haskell-backend", "type": "github" } @@ -140,16 +140,16 @@ "uv2nix": "uv2nix" }, "locked": { - "lastModified": 1778594571, - "narHash": "sha256-Y8Ape8of1FBkDAwIxk3vC0s0Yrkn/7Fa/u4MaKI8+Jo=", + "lastModified": 1781787476, + "narHash": "sha256-qJF6n4J9gf6bSR/G5iH4905xGHUVHyqKHW1dkgGBdhY=", "owner": "runtimeverification", "repo": "k", - "rev": "6ee29000016c6addb83b39ac865860f9542b3ebf", + "rev": "4a46d1231473b599c699160132fd6e76a5c46406", "type": "github" }, "original": { "owner": "runtimeverification", - "ref": "v7.1.323", + "ref": "v7.1.337", "repo": "k", "type": "github" } @@ -169,16 +169,16 @@ "utils": "utils" }, "locked": { - "lastModified": 1760570155, - "narHash": "sha256-jgDhxUFXMe7kTqdq6eSHshRJJzm/1QTmUc8SQIjN2sE=", + "lastModified": 1779992932, + "narHash": "sha256-Sa1MvKcQtOdCAZSeeEWk7RGmDRLzTvM74exhLPZ76IE=", "owner": "runtimeverification", "repo": "llvm-backend", - "rev": "618f530031870d6e8a74633b122d46afb5d7ad8e", + "rev": "f02284f09858cd2b9f310ad0142b3e04054295ec", "type": "github" }, "original": { "owner": "runtimeverification", - "ref": "v0.1.139", + "ref": "v0.1.140", "repo": "llvm-backend", "type": "github" } @@ -201,11 +201,11 @@ }, "nixpkgs-unstable": { "locked": { - "lastModified": 1769461804, - "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=", + "lastModified": 1781577229, + "narHash": "sha256-lrp67w8AulE9Ks53n27I45ADSzbOCn4H+CNW1Ck8B+8=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d", + "rev": "567a49d1913ce81ac6e9582e3553dd90a955875f", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index b21a379..7695257 100644 --- a/flake.nix +++ b/flake.nix @@ -9,7 +9,7 @@ # `k` package directly (replacing the imperative `kup install k`); its # nixpkgs is intentionally NOT followed, so the k-framework binary caches # are hit instead of rebuilding K against our nixpkgs. - k-framework.url = "github:runtimeverification/k/v7.1.323"; + k-framework.url = "github:runtimeverification/k/v7.1.337"; # Use the same uv2nix as k-framework so we inherit the pyproject-nix version # that fixes the missing 'riscv64' attribute in pep600.nix (pep599.manyLinuxTargetMachines # lookup now uses `or tagArch` as a safe default for unknown architectures). diff --git a/package/version b/package/version index 6e8bf73..17e51c3 100644 --- a/package/version +++ b/package/version @@ -1 +1 @@ -0.1.0 +0.1.1 diff --git a/pyproject.toml b/pyproject.toml index 7a2b03f..2c181fd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,14 +4,14 @@ build-backend = "hatchling.build" [project] name = "komet-node" -version = "0.1.0" +version = "0.1.1" description = "Local development testnet for Stellar based on K semantics" readme = "README.md" requires-python = "~=3.10" dependencies = [ "stellar-sdk>=13.2.1", - "komet@git+https://github.com/runtimeverification/komet.git@v0.1.88", - "kframework>=7.1.323,<7.1.324", + "komet@git+https://github.com/runtimeverification/komet.git@v0.1.89", + "kframework>=7.1.337,<7.1.338", ] [[project.authors]] diff --git a/src/komet_node/kdist/node.md b/src/komet_node/kdist/node.md index 6c794f2..d76bb4a 100644 --- a/src/komet_node/kdist/node.md +++ b/src/komet_node/kdist/node.md @@ -1262,6 +1262,7 @@ SCVal arg encoding (key order also significant): rule #decodeArgList(.JSONs) => .List rule #decodeArgList(A:JSON, AS:JSONs) => ListItem(#decodeArg(A)) #decodeArgList(AS) + rule #decodeArg({ "type" : "void" }) => Void rule #decodeArg({ "type" : "bool" , "value" : V:Bool }) => SCBool(V) rule #decodeArg({ "type" : "i32" , "value" : V:Int }) => I32(V) rule #decodeArg({ "type" : "u32" , "value" : V:Int }) => U32(V) @@ -1269,7 +1270,10 @@ SCVal arg encoding (key order also significant): rule #decodeArg({ "type" : "u64" , "value" : V:Int }) => U64(V) rule #decodeArg({ "type" : "i128" , "value" : V:Int }) => I128(V) rule #decodeArg({ "type" : "u128" , "value" : V:Int }) => U128(V) + rule #decodeArg({ "type" : "i256" , "value" : V:Int }) => I256(V) + rule #decodeArg({ "type" : "u256" , "value" : V:Int }) => U256(V) rule #decodeArg({ "type" : "symbol" , "value" : V:String }) => Symbol(V) + rule #decodeArg({ "type" : "string" , "value" : V:String }) => ScString(V) rule #decodeArg({ "type" : "bytes" , "value" : V:String }) => ScBytes(HexBytes(V)) rule #decodeArg({ "type" : "address" , "addrType" : "account" , "value" : V:String }) => ScAddress(Account(HexBytes(V))) rule #decodeArg({ "type" : "address" , "addrType" : "contract" , "value" : V:String }) => ScAddress(Contract(HexBytes(V))) diff --git a/src/komet_node/scval.py b/src/komet_node/scval.py index 29b9683..63c050f 100644 --- a/src/komet_node/scval.py +++ b/src/komet_node/scval.py @@ -19,6 +19,8 @@ def scval_to_json(scval: SCVal) -> dict: produced with keys in the same order as the ``#decodeArg`` rules in ``node.md``. """ match scval.type: + case SCValType.SCV_VOID: + return {'type': 'void'} case SCValType.SCV_BOOL: assert scval.b is not None return {'type': 'bool', 'value': scval.b} @@ -42,9 +44,25 @@ def scval_to_json(scval: SCVal) -> dict: assert scval.u128 is not None val = (scval.u128.hi.uint64 << 64) | scval.u128.lo.uint64 return {'type': 'u128', 'value': val} + case SCValType.SCV_U256: + assert scval.u256 is not None + u = scval.u256 + val = (u.hi_hi.uint64 << 192) | (u.hi_lo.uint64 << 128) | (u.lo_hi.uint64 << 64) | u.lo_lo.uint64 + return {'type': 'u256', 'value': val} + case SCValType.SCV_I256: + assert scval.i256 is not None + i = scval.i256 + # Only the top word is signed; the lower words are its two's complement, and + # OR-ing them onto the shifted signed word reproduces the value (inverse of + # the masking scval_from_json does). + val = (i.hi_hi.int64 << 192) | (i.hi_lo.uint64 << 128) | (i.lo_hi.uint64 << 64) | i.lo_lo.uint64 + return {'type': 'i256', 'value': val} case SCValType.SCV_SYMBOL: assert scval.sym is not None return {'type': 'symbol', 'value': scval.sym.sc_symbol.decode()} + case SCValType.SCV_STRING: + assert scval.str is not None + return {'type': 'string', 'value': scval.str.sc_string.decode()} case SCValType.SCV_BYTES: assert scval.bytes is not None return {'type': 'bytes', 'value': scval.bytes.sc_bytes.hex()} @@ -79,9 +97,8 @@ def scval_to_json(scval: SCVal) -> dict: def scval_from_json(value: dict) -> SCVal: """Decode the JSON ScVal encoding emitted by the semantics back into an XDR SCVal. - Inverse of :func:`scval_to_json`, extended with the value-only types the semantics can - hold in contract storage or return from a contract call but that never appear as call - arguments (``void``, ``string``, ``u256``, ``vec``, ``map``). Covers all three K-side + Inverse of :func:`scval_to_json`, which now covers every type in both directions, so + this decoder and that encoder handle the same set. Covers all three K-side encoders (``#scVal2JSON``, ``#scValJSON``, ``#scValToJSON`` in ``node.md``); the ``map`` case accepts both entry shapes they emit — ``{"key": ..., "val": ...}`` objects and ``[key, val]`` pairs — so keep the encoders and this decoder in sync. Raises @@ -120,6 +137,17 @@ def scval_from_json(value: dict) -> SCVal: lo_lo=stellar_xdr.Uint64(val & _UINT64_MASK), ) return stellar_xdr.SCVal(type=SCValType.SCV_U256, u256=parts256) + case 'i256': + # Only the top word is signed, so a negative value's remaining words are + # its two's complement -- which is what masking a negative Python int gives. + val = value['value'] + parts256i = stellar_xdr.Int256Parts( + hi_hi=stellar_xdr.Int64(val >> 192), + hi_lo=stellar_xdr.Uint64((val >> 128) & _UINT64_MASK), + lo_hi=stellar_xdr.Uint64((val >> 64) & _UINT64_MASK), + lo_lo=stellar_xdr.Uint64(val & _UINT64_MASK), + ) + return stellar_xdr.SCVal(type=SCValType.SCV_I256, i256=parts256i) case 'symbol': return stellar_xdr.SCVal(type=SCValType.SCV_SYMBOL, sym=stellar_xdr.SCSymbol(value['value'].encode())) case 'string': diff --git a/src/tests/integration/data/wasm/args.wat b/src/tests/integration/data/wasm/args.wat index e14d8d4..4d90fb1 100644 --- a/src/tests/integration/data/wasm/args.wat +++ b/src/tests/integration/data/wasm/args.wat @@ -32,6 +32,15 @@ (func $test_map (type 1) (param i64) (result i64) i64.const 2) + ;; test_string / test_void: accept 1 arg (a String object handle, resp. the small + ;; Void value), return Void. test_wide256: accept u256 and i256 handles. + (func $test_string (type 1) (param i64) (result i64) + i64.const 2) + (func $test_void (type 1) (param i64) (result i64) + i64.const 2) + (func $test_wide256 (type 3) (param i64 i64) (result i64) + i64.const 2) + (memory (;0;) 16) (global (;0;) (mut i32) (i32.const 1048576)) (global (;1;) i32 (i32.const 1048576)) @@ -45,6 +54,9 @@ (export "_" (func 4)) (export "test_vec" (func $test_vec)) (export "test_map" (func $test_map)) + (export "test_string" (func $test_string)) + (export "test_void" (func $test_void)) + (export "test_wide256" (func $test_wide256)) (export "__data_end" (global 1)) (export "__heap_base" (global 2)) ) diff --git a/src/tests/integration/test_server.py b/src/tests/integration/test_server.py index 0a0cee4..6a0787c 100644 --- a/src/tests/integration/test_server.py +++ b/src/tests/integration/test_server.py @@ -702,7 +702,8 @@ def test_call_tx_with_args(server: StellarRpcServer) -> None: Uses a minimal contract (args.wat) whose functions accept various arg types and return Void. For each call the arguments echoed in the trace's ``callContract`` frame must round-trip back to the exact SCVals that were sent — so a decoding bug is caught even - when the transaction still succeeds. Covers: bool, u32, i32, u64, i64, u128, i128, symbol. + when the transaction still succeeds. Covers: bool, u32, i32, u64, i64, u128, i128, symbol, + string, void, u256, i256. (Composite args have their own test below.) """ invoke = deploy_and_get_invoker(server, ARGS_CONTRACT_WAT) @@ -733,6 +734,34 @@ def assert_args_round_trip(func: str, args: list[xdr.SCVal]) -> None: ], ) assert_args_round_trip('test_symbol', [xdr.SCVal(type=SCValType.SCV_SYMBOL, sym=xdr.SCSymbol(sc_symbol=b'hello'))]) + assert_args_round_trip( + 'test_string', [xdr.SCVal(type=SCValType.SCV_STRING, str=xdr.SCString(sc_string=b'Soroban'))] + ) + assert_args_round_trip('test_void', [xdr.SCVal(type=SCValType.SCV_VOID)]) + + def u256(value: int) -> xdr.SCVal: + mask = (1 << 64) - 1 + parts = xdr.UInt256Parts( + hi_hi=xdr.Uint64(value >> 192), + hi_lo=xdr.Uint64((value >> 128) & mask), + lo_hi=xdr.Uint64((value >> 64) & mask), + lo_lo=xdr.Uint64(value & mask), + ) + return xdr.SCVal(type=SCValType.SCV_U256, u256=parts) + + def i256(value: int) -> xdr.SCVal: + # As for i128: only the top word is signed, so a negative value's lower words + # are its two's complement. + mask = (1 << 64) - 1 + parts = xdr.Int256Parts( + hi_hi=xdr.Int64(value >> 192), + hi_lo=xdr.Uint64((value >> 128) & mask), + lo_hi=xdr.Uint64((value >> 64) & mask), + lo_lo=xdr.Uint64(value & mask), + ) + return xdr.SCVal(type=SCValType.SCV_I256, i256=parts) + + assert_args_round_trip('test_wide256', [u256(2**200 + 33), i256(-(2**200) - 33)]) def test_call_tx_with_composite_args(server: StellarRpcServer) -> None: diff --git a/src/tests/unit/test_scval.py b/src/tests/unit/test_scval.py index 162c88c..7d6708b 100644 --- a/src/tests/unit/test_scval.py +++ b/src/tests/unit/test_scval.py @@ -1,10 +1,12 @@ -"""Unit tests for ``scval_to_json`` — the SCVal -> request-envelope JSON encoder. +"""Unit tests for ``scval_to_json`` — the SCVal -> request-envelope JSON encoder — +and for the 256-bit cases of its inverse, ``scval_from_json``. These are pure-Python tests (no K, no kdist build). They pin two things: * the JSON *shape* the K ``#decodeArg`` rules pattern-match on for composite - (vec / map) call arguments — key order is significant, so the expected dicts - are compared verbatim; and + (vec / map) call arguments and for the scalar types that used to be rejected as + arguments (``void``, ``string``, ``u256``, ``i256``) — key order is significant, + so the expected dicts are compared verbatim; and * that encoding a deeply nested composite value does not blow Python's default recursion limit (blocker #2). ``scval_to_json`` recurses with the value's structure, so a deep value is a deterministic proxy for the large-real-contract @@ -18,7 +20,7 @@ from stellar_sdk import xdr from stellar_sdk.xdr.sc_val_type import SCValType -from komet_node.scval import scval_to_json +from komet_node.scval import scval_from_json, scval_to_json def _sym(name: str) -> xdr.SCVal: @@ -132,3 +134,102 @@ def test_scval_to_json_deeply_nested_vec_survives_recursion_limit() -> None: assert len(encoded['value']) == 1 encoded = encoded['value'][0] assert encoded == {'type': 'symbol', 'value': 'leaf'} + + +def test_scval_from_json_u256() -> None: + """The semantics emit 256-bit values as a single integer; the parts are rebuilt here.""" + value = (1 << 192) | (2 << 128) | (3 << 64) | 4 + decoded = scval_from_json({'type': 'u256', 'value': value}) + assert decoded.type == SCValType.SCV_U256 + assert decoded.u256 is not None + assert (decoded.u256.hi_hi.uint64, decoded.u256.hi_lo.uint64) == (1, 2) + assert (decoded.u256.lo_hi.uint64, decoded.u256.lo_lo.uint64) == (3, 4) + + +def test_scval_from_json_i256_positive() -> None: + value = (1 << 192) | (2 << 128) | (3 << 64) | 4 + decoded = scval_from_json({'type': 'i256', 'value': value}) + assert decoded.type == SCValType.SCV_I256 + assert decoded.i256 is not None + assert (decoded.i256.hi_hi.int64, decoded.i256.hi_lo.uint64) == (1, 2) + assert (decoded.i256.lo_hi.uint64, decoded.i256.lo_lo.uint64) == (3, 4) + + +def test_scval_from_json_i256_negative() -> None: + """Only the i256 case can carry a negative value: the words are its two's complement.""" + mask = (1 << 64) - 1 + decoded = scval_from_json({'type': 'i256', 'value': -1}) + assert decoded.type == SCValType.SCV_I256 + assert decoded.i256 is not None + assert decoded.i256.hi_hi.int64 == -1 + assert decoded.i256.hi_lo.uint64 == mask + assert decoded.i256.lo_hi.uint64 == mask + assert decoded.i256.lo_lo.uint64 == mask + + +def test_scval_from_json_i256_min() -> None: + decoded = scval_from_json({'type': 'i256', 'value': -(2**255)}) + assert decoded.i256 is not None + assert decoded.i256.hi_hi.int64 == -(2**63) + assert (decoded.i256.hi_lo.uint64, decoded.i256.lo_hi.uint64, decoded.i256.lo_lo.uint64) == (0, 0, 0) + + +def _u256(value: int) -> xdr.SCVal: + mask = (1 << 64) - 1 + parts = xdr.UInt256Parts( + hi_hi=xdr.Uint64(value >> 192), + hi_lo=xdr.Uint64((value >> 128) & mask), + lo_hi=xdr.Uint64((value >> 64) & mask), + lo_lo=xdr.Uint64(value & mask), + ) + return xdr.SCVal(type=SCValType.SCV_U256, u256=parts) + + +def _i256(value: int) -> xdr.SCVal: + mask = (1 << 64) - 1 + parts = xdr.Int256Parts( + hi_hi=xdr.Int64(value >> 192), + hi_lo=xdr.Uint64((value >> 128) & mask), + lo_hi=xdr.Uint64((value >> 64) & mask), + lo_lo=xdr.Uint64(value & mask), + ) + return xdr.SCVal(type=SCValType.SCV_I256, i256=parts) + + +def test_scval_to_json_void() -> None: + """Void carries no payload, so it encodes to the single-key object #decodeArg matches.""" + encoded = scval_to_json(xdr.SCVal(type=SCValType.SCV_VOID)) + assert encoded == {'type': 'void'} + assert json.dumps(encoded) == '{"type": "void"}' + + +def test_scval_to_json_string() -> None: + """A String argument (e.g. hello_world's `to: String`) encodes like a symbol does.""" + encoded = scval_to_json(xdr.SCVal(type=SCValType.SCV_STRING, str=xdr.SCString(sc_string=b'Soroban'))) + assert encoded == {'type': 'string', 'value': 'Soroban'} + assert json.dumps(encoded) == '{"type": "string", "value": "Soroban"}' + + +def test_scval_to_json_string_empty_and_non_ascii() -> None: + assert scval_to_json(xdr.SCVal(type=SCValType.SCV_STRING, str=xdr.SCString(sc_string=b''))) == { + 'type': 'string', + 'value': '', + } + assert scval_to_json( + xdr.SCVal(type=SCValType.SCV_STRING, str=xdr.SCString(sc_string='üñî'.encode())) + ) == {'type': 'string', 'value': 'üñî'} + + +def test_scval_to_json_u256() -> None: + """The four words recombine into the single integer the semantics expect.""" + value = (1 << 192) | (2 << 128) | (3 << 64) | 4 + assert scval_to_json(_u256(value)) == {'type': 'u256', 'value': value} + assert scval_to_json(_u256(2**256 - 1)) == {'type': 'u256', 'value': 2**256 - 1} + + +def test_scval_to_json_i256_round_trips_through_from_json() -> None: + """Negative and extreme i256 values survive the encode/decode pair unchanged.""" + for value in (0, 33, -1, -(2**255), 2**255 - 1, -(1 << 192) | 7): + assert scval_to_json(_i256(value)) == {'type': 'i256', 'value': value} + decoded = scval_from_json(scval_to_json(_i256(value))) + assert decoded == _i256(value) diff --git a/uv.lock b/uv.lock index 0cf951d..23612ee 100644 --- a/uv.lock +++ b/uv.lock @@ -541,7 +541,7 @@ name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } wheels = [ @@ -703,7 +703,7 @@ wheels = [ [[package]] name = "kframework" -version = "7.1.323" +version = "7.1.337" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "coloredlogs" }, @@ -722,15 +722,15 @@ dependencies = [ { name = "tomli-w" }, { name = "xdg-base-dirs" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2a/d9/a88f051a023540ea9bbab889183bb87e01869c4ebf6565de32bd5b93b439/kframework-7.1.323.tar.gz", hash = "sha256:29f1ef525a29ba2a1410614ce05c4526e6e44b977232ca107f50ff2750d4e149", size = 245892, upload-time = "2026-05-12T14:44:19.937Z" } +sdist = { url = "https://files.pythonhosted.org/packages/82/14/b5e751e5be5c591cedfc8814a3e77ae729c145d89886fc9a18cf50b22938/kframework-7.1.337.tar.gz", hash = "sha256:9fdd05f228988757c9daee58564b45af424f0bc205912b0dd24b3d35a066b287", size = 253667, upload-time = "2026-06-18T13:51:13.311Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/db/d555255f53fdb36ffdcdfb303529f07e939018ddb58a4392eb13f19dbe4d/kframework-7.1.323-py3-none-any.whl", hash = "sha256:d0b23ccf44babb5e3ac735e00242d0a41435864ec66012d761cf6718aee53413", size = 297459, upload-time = "2026-05-12T14:44:18.443Z" }, + { url = "https://files.pythonhosted.org/packages/57/0e/e9a214527eb818915e6820c353d7b6078eb7611a34ebc285bdbf8ff7316b/kframework-7.1.337-py3-none-any.whl", hash = "sha256:f8e0ba4effda64c1f10fbc306518e7485e1b24ddef9706021b2bbfc04ab5cb7d", size = 305216, upload-time = "2026-06-18T13:51:11.807Z" }, ] [[package]] name = "komet" -version = "0.1.88" -source = { git = "https://github.com/runtimeverification/komet.git?rev=v0.1.88#673087c27e2024e45b03542ffd3f050ea3b6e69c" } +version = "0.1.89" +source = { git = "https://github.com/runtimeverification/komet.git?rev=v0.1.89#a078e296621a4f52fd1497fed64435e9948cc830" } dependencies = [ { name = "pykwasm" }, { name = "tomli" }, @@ -740,7 +740,7 @@ dependencies = [ [[package]] name = "komet-node" -version = "0.1.0" +version = "0.1.1" source = { editable = "." } dependencies = [ { name = "kframework" }, @@ -769,8 +769,8 @@ dev = [ [package.metadata] requires-dist = [ - { name = "kframework", specifier = ">=7.1.323,<7.1.324" }, - { name = "komet", git = "https://github.com/runtimeverification/komet.git?rev=v0.1.88" }, + { name = "kframework", specifier = ">=7.1.337,<7.1.338" }, + { name = "komet", git = "https://github.com/runtimeverification/komet.git?rev=v0.1.89" }, { name = "stellar-sdk", specifier = ">=13.2.1" }, ]