Revert "[DROP] ci: skip the toolchain ppa while launchpad is unreachable from the runners"

This reverts commit bacd1fac81.

.codecov.yml

@@ -1,6 +1,37 @@
+codecov:
+  require_ci_to_pass: true
+
+comment:
+  behavior: default
+  layout: reach,diff,flags,tree,reach
+  show_carryforward_flags: false
+
 coverage:
+  range: "60..80"
+  precision: 1
+  round: nearest
   status:
     project:
       default:
         target: 60%
         threshold: 2%
+    patch:
+      default:
+        target: auto
+        threshold: 2%
+    changes: false
+
+github_checks:
+  annotations: true
+
+parsers:
+  cobertura:
+    partials_as_hits: true
+    handle_missing_conditions : true
+
+slack_app: false
+
+ignore:
+  - "src/test/"
+  - "include/xrpl/beast/test/"
+  - "include/xrpl/beast/unit_test/"

.git-blame-ignore-revs

@@ -1,8 +1,25 @@
 # This feature requires Git >= 2.24
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
+# Format first-party source according to .clang-format
 50760c693510894ca368e90369b0cc2dabfd07f3
-e2384885f5f630c8f0ffe4bf21a169b433a16858
-241b9ddde9e11beb7480600fd5ed90e1ef109b21
-760f16f56835663d9286bd29294d074de26a7ba6
-0eebe6a5f4246fced516d52b83ec4e7f47373edd
+# Reintroduce Clang-Format & Levelization
+da1d20d6d5d862716125d60899b80fab5302954a
+# Consolidate external libraries
+da1d20d6d5d862716125d60899b80fab5302954a
+# Rename .hpp to .h
+0345a2645d0f5ad900f4fbbcaff96040d3a887fc
+# Format formerly .hpp files
+5a227dc719016e10045e17c9396ad401118044f1
+# Rewrite includes
+e61880699997398f5a746e6c4034edc7632661f5
+# Move CMake directory (#4997)
+e47b1c1b3b97c3f6d11858ee02f463596e29e7f0
+# Rearrange sources (#4997)
+bfafa2bb39e562901736d656806bd700c3699a2f
+# Rewrite includes (#4997)
+e61880699997398f5a746e6c4034edc7632661f5
+# Recompute loops (#4997)
+d25b5dcd568bb96c18e347d55fac10fe901a1bfb
+# Reformat code with clang-format-18
+02749feea88ce61c1f7eeb2d61a57d8ecf07ab11

.gitattributes

@@ -11,6 +11,3 @@ LICENSE binary
 *.vcxproj   text eol=crlf
 *.props     text eol=crlf
 *.filters   text eol=crlf
-
-# Mark it as generated and folded out by default
-src/test/app/SetJSHook_wasm.h linguist-generated=true

.github/workflows/check-genesis-hooks.yml

@@ -40,7 +40,7 @@ jobs:
         run: |
           # Download install.sh
           curl -o /tmp/wasienv-install.sh https://raw.githubusercontent.com/wasienv/wasienv/master/install.sh
-          
+
           # Replace /bin to /local/bin
           sed -i 's|/bin|/local/bin|g' /tmp/wasienv-install.sh
 

.github/workflows/clang-format.yml

@@ -20,7 +20,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install clang-format-${CLANG_VERSION}
     - name: Format first-party sources
-      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/quickjs/*" -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/verify-generated-headers.yml

@@ -16,6 +16,8 @@ jobs:
             generator: ./hook/generate_extern.sh
           - target: hook/sfcodes.h
             generator: bash ./hook/generate_sfcodes.sh
+          - target: hook/genesis/headers/sfcodes.h
+            generator: bash ./hook/generate_sfcodes.sh
           - target: hook/tts.h
             generator: ./hook/generate_tts.sh
           - target: hook/ls_flags.h

.gitignore

@@ -124,8 +124,6 @@ pkg
 CMakeUserPresets.json
 bld.rippled/
 
-# binary
-qjsc
 generated
 .vscode
 

Builds/levelization/results/loops.txt

@@ -26,7 +26,7 @@ Loop: xrpld.app xrpld.nodestore
   xrpld.app > xrpld.nodestore
 
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay ~= xrpld.app
+  xrpld.overlay == xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
   xrpld.app > xrpld.peerfinder

Builds/levelization/results/ordering.txt

@@ -12,6 +12,7 @@ libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
 libxrpl.server > xrpl.protocol
 libxrpl.server > xrpl.server
+test.app > test.shamap
 test.app > test.toplevel
 test.app > test.unit_test
 test.app > xrpl.basics
@@ -21,6 +22,7 @@ test.app > xrpld.ledger
 test.app > xrpld.nodestore
 test.app > xrpld.overlay
 test.app > xrpld.rpc
+test.app > xrpld.shamap
 test.app > xrpl.hook
 test.app > xrpl.json
 test.app > xrpl.protocol
@@ -36,6 +38,7 @@ test.beast > xrpl.basics
 test.conditions > xrpl.basics
 test.conditions > xrpld.conditions
 test.consensus > test.csf
+test.consensus > test.jtx
 test.consensus > test.toplevel
 test.consensus > test.unit_test
 test.consensus > xrpl.basics
@@ -43,6 +46,9 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpld.core
 test.consensus > xrpld.ledger
+test.consensus > xrpld.overlay
+test.consensus > xrpld.shamap
+test.consensus > xrpl.json
 test.consensus > xrpl.protocol
 test.core > test.jtx
 test.core > test.toplevel
@@ -77,6 +83,11 @@ test.ledger > xrpld.app
 test.ledger > xrpld.core
 test.ledger > xrpld.ledger
 test.ledger > xrpl.protocol
+test.net > test.toplevel
+test.net > xrpl.basics
+test.net > xrpld.core
+test.net > xrpld.net
+test.net > xrpl.json
 test.nodestore > test.jtx
 test.nodestore > test.toplevel
 test.nodestore > test.unit_test
@@ -84,6 +95,7 @@ test.nodestore > xrpl.basics
 test.nodestore > xrpld.core
 test.nodestore > xrpld.nodestore
 test.nodestore > xrpld.unity
+test.nodestore > xrpl.protocol
 test.overlay > test.jtx
 test.overlay > test.toplevel
 test.overlay > test.unit_test
@@ -118,6 +130,7 @@ test.rpc > xrpld.core
 test.rpc > xrpld.net
 test.rpc > xrpld.overlay
 test.rpc > xrpld.rpc
+test.rpc > xrpld.shamap
 test.rpc > xrpl.hook
 test.rpc > xrpl.json
 test.rpc > xrpl.protocol
@@ -150,7 +163,6 @@ xrpl.resource > xrpl.protocol
 xrpl.server > xrpl.basics
 xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
-xrpld.app > quickjs.toplevel
 xrpld.app > test.unit_test
 xrpld.app > xrpl.basics
 xrpld.app > xrpld.conditions
@@ -199,6 +211,7 @@ xrpld.rpc > xrpld.core
 xrpld.rpc > xrpld.ledger
 xrpld.rpc > xrpld.nodestore
 xrpld.rpc > xrpld.shamap
+xrpld.rpc > xrpl.hook
 xrpld.rpc > xrpl.json
 xrpld.rpc > xrpl.protocol
 xrpld.rpc > xrpl.resource

CMakeLists.txt

@@ -21,7 +21,11 @@ endif()
 project (xrpl)
 set(Boost_NO_BOOST_CMAKE ON)
 
-# make GIT_COMMIT_HASH define available to all sources
+# Only sources that expose Git metadata should rebuild when HEAD changes.
+set(git_info_sources
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/app/main/Main.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/app/misc/NetworkOPs.cpp")
+
 find_package(Git)
 if(Git_FOUND)
     execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse HEAD
@@ -29,7 +33,8 @@ if(Git_FOUND)
     if(gch)
         set(GIT_COMMIT_HASH "${gch}")
         message(STATUS gch: ${GIT_COMMIT_HASH})
-        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
+        set_property(SOURCE ${git_info_sources} APPEND PROPERTY
+            COMPILE_DEFINITIONS "GIT_COMMIT_HASH=\"${GIT_COMMIT_HASH}\"")
     endif()
 
     execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
@@ -37,7 +42,8 @@ if(Git_FOUND)
     if(gb)
         set(GIT_BRANCH "${gb}")
         message(STATUS gb: ${GIT_BRANCH})
-        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
+        set_property(SOURCE ${git_info_sources} APPEND PROPERTY
+            COMPILE_DEFINITIONS "GIT_BRANCH=\"${GIT_BRANCH}\"")
     endif()
 endif() #git
 
@@ -145,8 +151,6 @@ target_link_libraries(ripple_libs INTERFACE
   SQLite::SQLite3
 )
 
-include(deps/quickjs)
-
 if(coverage)
   include(RippledCov)
 endif()

README.md

@@ -2,7 +2,7 @@
 
 **Note:** Throughout this README, references to "we" or "our" pertain to the community and contributors involved in the Xahau network. It does not imply a legal entity or a specific collection of individuals.
 
-[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://xahau.network/)
+[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm under the normal XRPL assumptions about configured validator-list overlap, timing, and fault bounds, and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://xahau.network/)
 
 ## XAH
 XAH is the public, counterparty-free asset native to Xahau and functions primarily as network gas. Transactions submitted to the Xahau network must supply an appropriate amount of XAH, to be burnt by the network as a fee, in order to be successfully included in a validated ledger. In addition, XAH also acts as a bridge currency within the Xahau DEX. XAH is traded on the open-market and is available for anyone to access. Xahau was created in 2023 with a supply of 600 million units of XAH.

build-core.sh

@@ -95,8 +95,16 @@ if [[ "$4" == "" ]]; then
   echo "Non GH, local building, no Action runner magic"
 else
   # GH Action, runner
-  cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-  cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    if [[ "$(git rev-parse --abbrev-ref HEAD)" == "release" ]]; then
+        echo "building on the release branch... placing it in builds/candidate"
+        mkdir /data/builds/candidate
+        cp /io/release-build/xahaud /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    else
+        echo "building non-release branch, placing it in builds root"
+        cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    fi  
   echo "Published build to: http://build.xahau.tech/"
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi

build-full.sh

@@ -12,17 +12,16 @@ echo "-- GITHUB_REPOSITORY: $1"
 echo "-- GITHUB_SHA:        $2"
 echo "-- GITHUB_RUN_NUMBER: $4"
 
-umask 0000;
+umask 0000
 
 ####
 
-cd /io;
-mkdir -p src/certs;
-curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
-if [ "`grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l`" -eq "0" ]
-then
-    cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
-    perl -i -pe "s/^{/{
+cd /io
+mkdir -p src/certs
+curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h
+if [ "$(grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l)" -eq "0" ]; then
+  cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
+  perl -i -pe "s/^{/{
     #ifdef EMBEDDED_CA_BUNDLE
     BIO *cbio = BIO_new_mem_buf(ca_bundle.data(), ca_bundle.size());
     X509_STORE  *cts = SSL_CTX_get_cert_store(ctx.native_handle());
@@ -68,15 +67,14 @@ fi
 source /opt/rh/gcc-toolset-11/enable
 export PATH=/usr/local/bin:$PATH
 export CC='/usr/lib64/ccache/gcc' &&
-export CXX='/usr/lib64/ccache/g++' &&
-echo "-- Build Rippled --" &&
-pwd &&
+  export CXX='/usr/lib64/ccache/g++' &&
+  echo "-- Build Rippled --" &&
+  pwd &&
+  echo "MOVING TO [ build-core.sh ]"
 
-echo "MOVING TO [ build-core.sh ]";
-
-printenv > .env.temp;
-cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g|sed s/\$/\\\"/g > .env;
-rm .env.temp;
+printenv >.env.temp
+cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g | sed s/\$/\\\"/g >.env
+rm .env.temp
 
 echo "Persisting ENV:"
 cat .env

cfg/genesis.json

@@ -62,8 +62,7 @@
           "3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87",
           "0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3",
           "6E739F4F8B07BED29FC9FF440DA3C301CD14A180DF45819F658FEC2F7DE31427",
-          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6",
-          "DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536"
+          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6"
         ],
         "Flags": 0,
         "LedgerEntryType": "Amendments",

cfg/xahaud-example.cfg

@@ -494,7 +494,7 @@
 #
 #   Configure the maximum number of transactions to have in the job queue
 #
-#   Must be a number between 100 and 1000, defaults to 250
+#   Must be a number between 100 and 1000, defaults to 1000
 #
 #
 # [overlay]
@@ -593,7 +593,7 @@
 #       reaches or exceeds this number. After that the limit may still
 #       change, but will stay above the target. If consensus is not
 #       healthy, the limit will be clamped to this value or lower.
-#       Default: 50.
+#       Default: 1000.
 #
 #   maximum_txn_in_ledger = <number>
 #

cfg/xahaud-standalone.cfg

@@ -1,4 +1,4 @@
-# standalone: ./xahaud -a --ledgerfile cfg/genesis.json --conf cfg/xahaud-standalone.cfg
+# standalone: ./xahaud -a --ledgerfile config/genesis.json --conf config/xahaud-standalone.cfg
 [server]
 port_rpc_admin_local
 port_ws_public
@@ -146,12 +146,9 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87 NonFungibleTokensV1
 0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3 fixNFTokenDirV1
 36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
-4C499D17719BB365B69010A436B64FD1A82AAB199FC1CEB06962EBD01059FB09 fixXahauV1
-215181D23BF5C173314B5FDB9C872C92DE6CC918483727DE037C0C13E7E6EE9D fixXahauV2
 0D8BF22FF7570D58598D1EF19EBB6E142AD46E59A223FD3816262FBB69345BEA Remit
 7CA0426E7F411D39BB014E57CD9E08F61DE1750F0D41FCD428D9FB80BB7596B0 ZeroB2M
 4B8466415FAB32FFA89D9DCBE166A42340115771DF611A7160F8D7439C87ECD8 fixNSDelete
 EDB4EE4C524E16BDD91D9A529332DED08DCAAA51CC6DC897ACFA1A0ED131C5B6 fix240819
 8063140E9260799D6716756B891CEC3E7006C4E4F277AB84670663A88F94B9C4 fixPageCap
 88693F108C3CD8A967F3F4253A32DEF5E35F9406ACD2A11B88B11D90865763A9 fix240911
-DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536 JsHooks

cmake/CodeCoverage.cmake

@@ -95,6 +95,9 @@
 #     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
 #     - add support for all gcovr output formats
 #
+# 2024-04-03, Bronek Kozicki
+#     - add support for output formats: jacoco, clover, lcov
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -256,10 +259,10 @@ endif()
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     FORMAT "cobertura"                     # Output format, one of:
-#                                            #  xml cobertura sonarqube json-summary
-#                                            #  json-details coveralls csv txt
-#                                            #  html-single html-nested html-details
-#                                            #  (xml is an alias to cobertura;
+#                                            #  xml cobertura sonarqube jacoco clover
+#                                            #  json-summary json-details coveralls csv
+#                                            #  txt html-single html-nested html-details
+#                                            #  lcov (xml is an alias to cobertura;
 #                                            #  if no format is set, defaults to xml)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
@@ -308,6 +311,8 @@ function(setup_target_for_coverage_gcovr)
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
         elseif(Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
         else()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
         endif()
@@ -320,6 +325,14 @@ function(setup_target_for_coverage_gcovr)
         set(Coverage_FORMAT cobertura) # overwrite xml
     elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
+    elseif(Coverage_FORMAT STREQUAL "clover")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
+    elseif(Coverage_FORMAT STREQUAL "lcov")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
     elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)

cmake/RippledCore.cmake

@@ -58,7 +58,6 @@ target_link_libraries(xrpl.imports.main
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge
-    NIH::quickjs
     Ripple::opts
     Ripple::syslibs
     absl::random_random
@@ -166,6 +165,9 @@ if(xrpld)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
   endif()
+  if(xahaud_runtime_test_config)
+    target_compile_definitions(rippled PUBLIC XAHAUD_ENABLE_RUNTIME_TEST_CONFIG=1)
+  endif()
   target_include_directories(rippled
     PRIVATE
       $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
@@ -181,6 +183,21 @@ if(xrpld)
       "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
     )
     target_sources(rippled PRIVATE ${sources})
+
+    set(HOOKS_TEST_DIR "" CACHE PATH "External hook Env-test directory")
+    if(NOT HOOKS_TEST_DIR AND DEFINED ENV{HOOKS_TEST_DIR})
+      set(HOOKS_TEST_DIR "$ENV{HOOKS_TEST_DIR}")
+    endif()
+    if(HOOKS_TEST_DIR)
+      file(GLOB_RECURSE hook_test_sources CONFIGURE_DEPENDS
+        "${HOOKS_TEST_DIR}/*_test.cpp"
+      )
+      if(hook_test_sources)
+        message(STATUS "Including external hook Env tests from ${HOOKS_TEST_DIR}")
+        target_sources(rippled PRIVATE ${hook_test_sources})
+        target_include_directories(rippled PRIVATE "${HOOKS_TEST_DIR}")
+      endif()
+    endif()
   endif()
 
   target_link_libraries(rippled

cmake/RippledInstall.cmake

@@ -6,7 +6,6 @@ include(create_symbolic_link)
 
 install (
   TARGETS
-    quickjs
     common
     opts
     ripple_syslibs

cmake/RippledInterface.cmake

@@ -22,6 +22,9 @@ target_compile_definitions (opts
     $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
     $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
     $<$<BOOL:${single_io_service_thread}>:RIPPLE_SINGLE_IO_SERVICE_THREAD=1>
+    # Enhanced logging is enabled for Debug builds, or explicitly via
+    # -DBEAST_ENHANCED_LOGGING=ON for other build types.
+    $<$<OR:$<CONFIG:Debug>,$<BOOL:${BEAST_ENHANCED_LOGGING}>>:BEAST_ENHANCED_LOGGING=1>
     $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
 target_compile_options (opts
   INTERFACE

cmake/RippledSettings.cmake

@@ -12,6 +12,13 @@ option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
 
+option(xahaud_runtime_test_config
+  "Enable XAHAUD_RUNTIME_TEST_CONFIG env and runtime_config RPC fault-injection controls"
+  OFF)
+# Conan 2 local opt-in:
+# [conf]
+# tools.cmake.cmaketoolchain:extra_variables={"xahaud_runtime_test_config":"ON"}
+
 option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
   if(NOT is_ci)

cmake/deps/quickjs.cmake

@@ -1,52 +0,0 @@
-# QuickJS source files
-set(QUICKJS_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libutf.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/qsort_r.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/tutf8e.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/vector.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/char-utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/buffer-utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/ringbuffer.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libunicode.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/cutils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-libc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libbf.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-textcode.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-internal.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/debug.c
-)
-
-# QuickJS include directories
-set(QUICKJS_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs)
-
-# RHTODO: Fix this to be dynamic
-set(QUICKJS_VERSION "2023-01-01")
-
-# QuickJS compile definitions
-set(QUICKJS_COMPILE_DEFINITIONS
-    _GNU_SOURCE
-    CONFIG_VERSION="${QUICKJS_VERSION}"
-    CONFIG_BIGNUM
-)
-
-# Create static library
-add_library(quickjs STATIC ${QUICKJS_SOURCES})
-target_include_directories(quickjs
-  PUBLIC
-    $<BUILD_INTERFACE:${QUICKJS_INCLUDE_DIRS}>
-    $<INSTALL_INTERFACE:include/quickjs>
-)
-target_compile_definitions(quickjs PUBLIC ${QUICKJS_COMPILE_DEFINITIONS})
-
-add_library(NIH::quickjs ALIAS quickjs)
-target_link_libraries(ripple_libs INTERFACE NIH::quickjs)
-
-install(
-    FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/*.h
-    DESTINATION include/quickjs
-)

hook/error.h

@@ -47,5 +47,8 @@
 #define MEM_OVERLAP -43
 #define TOO_MANY_STATE_MODIFICATIONS -44
 #define TOO_MANY_NAMESPACES -45
+#define EXPORT_FAILURE -46
+#define TOO_MANY_EXPORTED_TXN -47
+#define TOO_LITTLE_ENTROPY -48
 #define HOOK_ERROR_CODES
 #endif //HOOK_ERROR_CODES

hook/extern.h

@@ -2,6 +2,9 @@
 // Generated using generate_extern.sh
 #include <stdint.h>
 #ifndef HOOK_EXTERN
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 extern int32_t __attribute__((noduplicate))
 _g(uint32_t guard_id, uint32_t maxiter);
@@ -336,5 +339,55 @@ prepare(
     uint32_t read_ptr,
     uint32_t read_len);
 
+extern int64_t
+xport_reserve(uint32_t count);
+
+// callback_fee_drops: 0 omits third-party delivery permission; otherwise the
+// exact Import fee authorized by the emitted Export intent, in native drops.
+extern int64_t
+xport(
+    uint32_t write_ptr,
+    uint32_t write_len,
+    uint32_t read_ptr,
+    uint32_t read_len,
+    uint32_t committee_hash_ptr,
+    uint32_t committee_hash_len,
+    uint64_t callback_fee_drops);
+
+extern int64_t
+xport_cancel(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
+
+/*
+    Consensus entropy APIs.
+
+    min_tier is a required fail-closed floor:
+      1 = consensus_fallback, 2 = participant_aligned,
+      3 = validator_quorum, 4 = validator_full.
+
+    entropy_cr_status returns a packed non-negative value:
+      bits 32..39 tier, 16..31 count, 0..15 denominator.
+    Check for a negative error before using the ENTROPY_* macros.
+
+    Classify tier before count/denominator arithmetic: fallback is tier 1
+    with count=denominator=0. Common policies are denominator-count <= 1,
+    5*count >= 4*denominator (use widened arithmetic), or count >= floor.
+
+    entropy_cr_dice/entropy_cr_random return TOO_LITTLE_ENTROPY if fresh
+    visible entropy is below
+    min_tier. Open-ledger and simulate execution are provisional previews;
+    final ordered execution may see a different entropy object.
+*/
+extern int64_t
+entropy_cr_dice(uint32_t sides, uint32_t min_tier);
+
+extern int64_t
+entropy_cr_random(uint32_t write_ptr, uint32_t write_len, uint32_t min_tier);
+
+extern int64_t
+entropy_cr_status(void);
+
+#ifdef __cplusplus
+}
+#endif
 #define HOOK_EXTERN
 #endif  // HOOK_EXTERN

hook/generate_error.sh

@@ -9,7 +9,7 @@ ENUM_FILE="$SCRIPT_DIR/../include/xrpl/hook/Enum.h"
 echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
 echo '// Generated using generate_error.sh'
 echo '#ifndef HOOK_ERROR_CODES'
-sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
+sed -n '/enum class hook_return_code/,/};/p' "$ENUM_FILE" |
     awk '
         function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s }
         function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s }
@@ -31,7 +31,7 @@ sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
 
         {
             line = $0
-            if (line ~ /enum[[:space:]]+hook_return_code/)
+            if (line ~ /enum[[:space:]]+class[[:space:]]+hook_return_code/)
                 next
             if (line ~ /^[[:space:]]*\{/)
                 next

hook/generate_extern.sh

@@ -11,6 +11,9 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
     echo '// Generated using generate_extern.sh'
     echo '#include <stdint.h>'
     echo '#ifndef HOOK_EXTERN'
+    echo '#ifdef __cplusplus'
+    echo 'extern "C" {'
+    echo '#endif'
     echo
     awk '
         function trim(s) {
@@ -27,8 +30,8 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
                 next;
             }
             
-            # Look for comment lines that start with // int64_t or // int32_t
-            if (line ~ /^[[:space:]]*\/\/[[:space:]]*(int64_t|int32_t)[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
+            # Look for comment lines that start with // and contain function signature
+            if (line ~ /^[[:space:]]*\/\/[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
                 # Remove leading // and trim
                 sub(/^[[:space:]]*\/\/[[:space:]]*/, "", line);
                 line = trim(line);
@@ -38,6 +41,34 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
                     # Insert __attribute__((noduplicate)) before _g
                     sub(/[[:space:]]+_g/, " __attribute__((noduplicate)) _g", line);
                 }
+
+                if (line ~ /[[:space:]]+xport[[:space:]]*\(/) {
+                    print "// callback_fee_drops: 0 omits third-party delivery permission; otherwise the";
+                    print "// exact Import fee authorized by the emitted Export intent, in native drops.";
+                }
+
+                if (line ~ /[[:space:]]+entropy_cr_dice[[:space:]]*\(/) {
+                    print "/*";
+                    print "    Consensus entropy APIs.";
+                    print "";
+                    print "    min_tier is a required fail-closed floor:";
+                    print "      1 = consensus_fallback, 2 = participant_aligned,";
+                    print "      3 = validator_quorum, 4 = validator_full.";
+                    print "";
+                    print "    entropy_cr_status returns a packed non-negative value:";
+                    print "      bits 32..39 tier, 16..31 count, 0..15 denominator.";
+                    print "    Check for a negative error before using the ENTROPY_* macros.";
+                    print "";
+                    print "    Classify tier before count/denominator arithmetic: fallback is tier 1";
+                    print "    with count=denominator=0. Common policies are denominator-count <= 1,";
+                    print "    5*count >= 4*denominator (use widened arithmetic), or count >= floor.";
+                    print "";
+                    print "    entropy_cr_dice/entropy_cr_random return TOO_LITTLE_ENTROPY if fresh";
+                    print "    visible entropy is below";
+                    print "    min_tier. Open-ledger and simulate execution are provisional previews;";
+                    print "    final ordered execution may see a different entropy object.";
+                    print "*/";
+                }
                 
                 # printf("\n");
                 
@@ -46,6 +77,9 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
         }
     ' "$APPLY_HOOK"
 
+    echo '#ifdef __cplusplus'
+    echo '}'
+    echo '#endif'
     echo '#define HOOK_EXTERN'
     echo '#endif  // HOOK_EXTERN'
 } | (

hook/genesis/headers/extern.h

@@ -348,5 +348,24 @@ util_verify(
     uint32_t kread_len);
 
 extern int64_t xpop_slot(uint32_t, uint32_t);
+
+extern int64_t
+xport_reserve(uint32_t count);
+
+// callback_fee_drops: 0 omits third-party delivery permission; otherwise the
+// exact Import fee authorized by the emitted Export intent, in native drops.
+extern int64_t
+xport(
+    uint32_t write_ptr,
+    uint32_t write_len,
+    uint32_t read_ptr,
+    uint32_t read_len,
+    uint32_t committee_hash_ptr,
+    uint32_t committee_hash_len,
+    uint64_t callback_fee_drops);
+
+extern int64_t
+xport_cancel(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
+
 #define HOOK_EXTERN
-#endif  // HOOK_EXTERN
+#endif  // HOOK_EXTERN

hook/genesis/headers/hookapi.h

@@ -47,4 +47,4 @@
 #include "macro.h"
 #include "types.h"
 
-#endif
+#endif

hook/genesis/headers/macro.h

@@ -607,31 +607,37 @@ int out_len = 0;\
 #define PREPARE_PAYMENT_SIMPLE_SIZE 248U
 #endif
 
-#define PREPARE_PAYMENT_SIMPLE(buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint64_t drops_amount = (drops_amount_raw);\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_DROPS_AMOUNT         (buf_out, drops_amount                   );      /* amount  | size   9 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        int64_t edlen = etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_SIZE);       /* emitdet | size 1?? */ \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);                                    \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
+#define PREPARE_PAYMENT_SIMPLE(                                              \
+    buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw) \
+    {                                                                        \
+        uint8_t* buf_out = buf_out_master;                                   \
+        uint8_t acc[20];                                                     \
+        uint64_t drops_amount = (drops_amount_raw);                          \
+        uint32_t dest_tag = (dest_tag_raw);                                  \
+        uint32_t src_tag = (src_tag_raw);                                    \
+        uint32_t cls = (uint32_t)ledger_seq();                               \
+        hook_account(SBUF(acc));                                             \
+        _01_02_ENCODE_TT(buf_out, ttPAYMENT);      /* uint16  | size   3 */  \
+        _02_02_ENCODE_FLAGS(buf_out, tfCANONICAL); /* uint32  | size   5 */  \
+        _02_03_ENCODE_TAG_SRC(buf_out, src_tag);   /* uint32  | size   5 */  \
+        _02_04_ENCODE_SEQUENCE(buf_out, 0);        /* uint32  | size   5 */  \
+        _02_14_ENCODE_TAG_DST(buf_out, dest_tag);  /* uint32  | size   5 */  \
+        _02_26_ENCODE_FLS(buf_out, cls + 1);       /* uint32  | size   6 */  \
+        _02_27_ENCODE_LLS(buf_out, cls + 5);       /* uint32  | size   6 */  \
+        _06_01_ENCODE_DROPS_AMOUNT(                                          \
+            buf_out, drops_amount); /* amount  | size   9 */                 \
+        uint8_t* fee_ptr = buf_out;                                          \
+        _06_08_ENCODE_DROPS_FEE(buf_out, 0);        /* amount  | size   9 */ \
+        _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out); /* pk      | size  35 */ \
+        _08_01_ENCODE_ACCOUNT_SRC(buf_out, acc);    /* account | size  22 */ \
+        _08_03_ENCODE_ACCOUNT_DST(                                           \
+            buf_out, to_address); /* account | size  22 */                   \
+        int64_t edlen = etxn_details(                                        \
+            (uint32_t)buf_out,                                               \
+            PREPARE_PAYMENT_SIMPLE_SIZE); /* emitdet | size 1?? */           \
+        int64_t fee =                                                        \
+            etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);      \
+        _06_08_ENCODE_DROPS_FEE(fee_ptr, fee);                               \
     }
 
 #ifdef HAS_CALLBACK
@@ -639,33 +645,35 @@ int out_len = 0;\
 #else
 #define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 287
 #endif
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_TL_AMOUNT            (buf_out, tlamt                          );      /* amount  | size  48 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);             /* emitdet | size 1?? */  \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);                          \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
+#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(                                    \
+    buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)            \
+    {                                                                        \
+        uint8_t* buf_out = buf_out_master;                                   \
+        uint8_t acc[20];                                                     \
+        uint32_t dest_tag = (dest_tag_raw);                                  \
+        uint32_t src_tag = (src_tag_raw);                                    \
+        uint32_t cls = (uint32_t)ledger_seq();                               \
+        hook_account(SBUF(acc));                                             \
+        _01_02_ENCODE_TT(buf_out, ttPAYMENT);      /* uint16  | size   3 */  \
+        _02_02_ENCODE_FLAGS(buf_out, tfCANONICAL); /* uint32  | size   5 */  \
+        _02_03_ENCODE_TAG_SRC(buf_out, src_tag);   /* uint32  | size   5 */  \
+        _02_04_ENCODE_SEQUENCE(buf_out, 0);        /* uint32  | size   5 */  \
+        _02_14_ENCODE_TAG_DST(buf_out, dest_tag);  /* uint32  | size   5 */  \
+        _02_26_ENCODE_FLS(buf_out, cls + 1);       /* uint32  | size   6 */  \
+        _02_27_ENCODE_LLS(buf_out, cls + 5);       /* uint32  | size   6 */  \
+        _06_01_ENCODE_TL_AMOUNT(buf_out, tlamt);   /* amount  | size  48 */  \
+        uint8_t* fee_ptr = buf_out;                                          \
+        _06_08_ENCODE_DROPS_FEE(buf_out, 0);        /* amount  | size   9 */ \
+        _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out); /* pk      | size  35 */ \
+        _08_01_ENCODE_ACCOUNT_SRC(buf_out, acc);    /* account | size  22 */ \
+        _08_03_ENCODE_ACCOUNT_DST(                                           \
+            buf_out, to_address); /* account | size  22 */                   \
+        etxn_details(                                                        \
+            (uint32_t)buf_out,                                               \
+            PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE); /* emitdet | size 1?? */ \
+        int64_t fee = etxn_fee_base(                                         \
+            buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);          \
+        _06_08_ENCODE_DROPS_FEE(fee_ptr, fee);                               \
     }
 
-
-
 #endif
-

hook/genesis/headers/sfcodes.h

@@ -3,18 +3,31 @@
 #define sfCloseResolution ((16U << 16U) + 1U)
 #define sfMethod ((16U << 16U) + 2U)
 #define sfTransactionResult ((16U << 16U) + 3U)
+#define sfScale ((16U << 16U) + 4U)
+#define sfAssetScale ((16U << 16U) + 5U)
 #define sfTickSize ((16U << 16U) + 16U)
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
+#define sfWasLockingChainSend ((16U << 16U) + 19U)
+#define sfSidecarType ((16U << 16U) + 20U)
+#define sfEntropyTier ((16U << 16U) + 21U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
 #define sfTransferFee ((1U << 16U) + 4U)
+#define sfTradingFee ((1U << 16U) + 5U)
+#define sfDiscountedFee ((1U << 16U) + 6U)
 #define sfVersion ((1U << 16U) + 16U)
 #define sfHookStateChangeCount ((1U << 16U) + 17U)
 #define sfHookEmitCount ((1U << 16U) + 18U)
 #define sfHookExecutionIndex ((1U << 16U) + 19U)
 #define sfHookApiVersion ((1U << 16U) + 20U)
+#define sfHookStateScale ((1U << 16U) + 21U)
+#define sfLedgerFixType ((1U << 16U) + 22U)
+#define sfHookExportCount ((1U << 16U) + 98U)
+#define sfEntropyCount ((1U << 16U) + 99U)
+#define sfEntropyDenominator ((1U << 16U) + 100U)
+#define sfExportCount ((1U << 16U) + 101U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -29,6 +42,7 @@
 #define sfWalletSize ((2U << 16U) + 12U)
 #define sfOwnerCount ((2U << 16U) + 13U)
 #define sfDestinationTag ((2U << 16U) + 14U)
+#define sfLastUpdateTime ((2U << 16U) + 15U)
 #define sfHighQualityIn ((2U << 16U) + 16U)
 #define sfHighQualityOut ((2U << 16U) + 17U)
 #define sfLowQualityIn ((2U << 16U) + 18U)
@@ -60,7 +74,15 @@
 #define sfBurnedNFTokens ((2U << 16U) + 44U)
 #define sfHookStateCount ((2U << 16U) + 45U)
 #define sfEmitGeneration ((2U << 16U) + 46U)
-#define sfLockCount ((2U << 16U) + 47U)
+#define sfVoteWeight ((2U << 16U) + 48U)
+#define sfLockCount ((2U << 16U) + 49U)
+#define sfFirstNFTokenSequence ((2U << 16U) + 50U)
+#define sfOracleDocumentID ((2U << 16U) + 51U)
+#define sfStartTime ((2U << 16U) + 93U)
+#define sfRepeatCount ((2U << 16U) + 94U)
+#define sfDelaySeconds ((2U << 16U) + 95U)
+#define sfXahauActivationLgrSeq ((2U << 16U) + 96U)
+#define sfImportSequence ((2U << 16U) + 97U)
 #define sfRewardTime ((2U << 16U) + 98U)
 #define sfRewardLgrFirst ((2U << 16U) + 99U)
 #define sfRewardLgrLast ((2U << 16U) + 100U)
@@ -80,12 +102,26 @@
 #define sfHookInstructionCount ((3U << 16U) + 17U)
 #define sfHookReturnCode ((3U << 16U) + 18U)
 #define sfReferenceCount ((3U << 16U) + 19U)
+#define sfXChainClaimID ((3U << 16U) + 20U)
+#define sfXChainAccountCreateCount ((3U << 16U) + 21U)
+#define sfXChainAccountClaimCount ((3U << 16U) + 22U)
+#define sfAssetPrice ((3U << 16U) + 23U)
+#define sfMaximumAmount ((3U << 16U) + 24U)
+#define sfOutstandingAmount ((3U << 16U) + 25U)
+#define sfMPTAmount ((3U << 16U) + 26U)
+#define sfIssuerNode ((3U << 16U) + 27U)
+#define sfSubjectNode ((3U << 16U) + 28U)
+#define sfExportNode ((3U << 16U) + 29U)
+#define sfTouchCount ((3U << 16U) + 97U)
+#define sfAccountIndex ((3U << 16U) + 98U)
+#define sfAccountCount ((3U << 16U) + 99U)
 #define sfRewardAccumulator ((3U << 16U) + 100U)
 #define sfEmailHash ((4U << 16U) + 1U)
-#define sfTakerPaysCurrency ((10U << 16U) + 1U)
-#define sfTakerPaysIssuer ((10U << 16U) + 2U)
-#define sfTakerGetsCurrency ((10U << 16U) + 3U)
-#define sfTakerGetsIssuer ((10U << 16U) + 4U)
+#define sfTakerPaysCurrency ((17U << 16U) + 1U)
+#define sfTakerPaysIssuer ((17U << 16U) + 2U)
+#define sfTakerGetsCurrency ((17U << 16U) + 3U)
+#define sfTakerGetsIssuer ((17U << 16U) + 4U)
+#define sfMPTokenIssuanceID ((21U << 16U) + 1U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -99,6 +135,8 @@
 #define sfEmitParentTxnID ((5U << 16U) + 11U)
 #define sfEmitNonce ((5U << 16U) + 12U)
 #define sfEmitHookHash ((5U << 16U) + 13U)
+#define sfObjectID ((5U << 16U) + 14U)
+#define sfAMMID ((5U << 16U) + 15U)
 #define sfBookDirectory ((5U << 16U) + 16U)
 #define sfInvoiceID ((5U << 16U) + 17U)
 #define sfNickname ((5U << 16U) + 18U)
@@ -120,6 +158,18 @@
 #define sfOfferID ((5U << 16U) + 34U)
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
+#define sfDomainID ((5U << 16U) + 37U)
+#define sfExportSignatureHash ((5U << 16U) + 38U)
+#define sfExportCommitteeHash ((5U << 16U) + 39U)
+#define sfManifestID ((5U << 16U) + 91U)
+#define sfHookOnOutgoing ((5U << 16U) + 93U)
+#define sfHookOnIncoming ((5U << 16U) + 94U)
+#define sfCron ((5U << 16U) + 95U)
+#define sfHookCanEmit ((5U << 16U) + 96U)
+#define sfEmittedTxnID ((5U << 16U) + 97U)
+#define sfGovernanceMarks ((5U << 16U) + 98U)
+#define sfGovernanceFlags ((5U << 16U) + 99U)
+#define sfNumber ((9U << 16U) + 1U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -130,12 +180,27 @@
 #define sfFee ((6U << 16U) + 8U)
 #define sfSendMax ((6U << 16U) + 9U)
 #define sfDeliverMin ((6U << 16U) + 10U)
+#define sfAmount2 ((6U << 16U) + 11U)
+#define sfBidMin ((6U << 16U) + 12U)
+#define sfBidMax ((6U << 16U) + 13U)
 #define sfMinimumOffer ((6U << 16U) + 16U)
 #define sfRippleEscrow ((6U << 16U) + 17U)
 #define sfDeliveredAmount ((6U << 16U) + 18U)
 #define sfNFTokenBrokerFee ((6U << 16U) + 19U)
 #define sfHookCallbackFee ((6U << 16U) + 20U)
 #define sfLockedBalance ((6U << 16U) + 21U)
+#define sfBaseFeeDrops ((6U << 16U) + 22U)
+#define sfReserveBaseDrops ((6U << 16U) + 23U)
+#define sfReserveIncrementDrops ((6U << 16U) + 24U)
+#define sfLPTokenOut ((6U << 16U) + 25U)
+#define sfLPTokenIn ((6U << 16U) + 26U)
+#define sfEPrice ((6U << 16U) + 27U)
+#define sfPrice ((6U << 16U) + 28U)
+#define sfSignatureReward ((6U << 16U) + 29U)
+#define sfMinAccountCreateAmount ((6U << 16U) + 30U)
+#define sfLPTokenBalance ((6U << 16U) + 31U)
+#define sfExportCallbackFee ((6U << 16U) + 32U)
+#define sfTrustLineRewardAccumulator ((6U << 16U) + 99U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -161,6 +226,18 @@
 #define sfHookParameterName ((7U << 16U) + 24U)
 #define sfHookParameterValue ((7U << 16U) + 25U)
 #define sfBlob ((7U << 16U) + 26U)
+#define sfDIDDocument ((7U << 16U) + 27U)
+#define sfData ((7U << 16U) + 28U)
+#define sfAssetClass ((7U << 16U) + 29U)
+#define sfProvider ((7U << 16U) + 30U)
+#define sfMPTokenMetadata ((7U << 16U) + 31U)
+#define sfCredentialType ((7U << 16U) + 32U)
+#define sfEntropyContributors ((7U << 16U) + 33U)
+#define sfExportCommittee ((7U << 16U) + 34U)
+#define sfExportContributors ((7U << 16U) + 35U)
+#define sfHookName ((7U << 16U) + 97U)
+#define sfRemarkValue ((7U << 16U) + 98U)
+#define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
 #define sfOwner ((8U << 16U) + 2U)
 #define sfDestination ((8U << 16U) + 3U)
@@ -170,13 +247,32 @@
 #define sfRegularKey ((8U << 16U) + 8U)
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
+#define sfHolder ((8U << 16U) + 11U)
 #define sfHookAccount ((8U << 16U) + 16U)
+#define sfOtherChainSource ((8U << 16U) + 18U)
+#define sfOtherChainDestination ((8U << 16U) + 19U)
+#define sfAttestationSignerAccount ((8U << 16U) + 20U)
+#define sfAttestationRewardAccount ((8U << 16U) + 21U)
+#define sfLockingChainDoor ((8U << 16U) + 22U)
+#define sfIssuingChainDoor ((8U << 16U) + 23U)
+#define sfSubject ((8U << 16U) + 24U)
+#define sfInform ((8U << 16U) + 99U)
 #define sfIndexes ((19U << 16U) + 1U)
 #define sfHashes ((19U << 16U) + 2U)
 #define sfAmendments ((19U << 16U) + 3U)
 #define sfNFTokenOffers ((19U << 16U) + 4U)
 #define sfHookNamespaces ((19U << 16U) + 5U)
+#define sfCredentialIDs ((19U << 16U) + 6U)
+#define sfURITokenIDs ((19U << 16U) + 99U)
 #define sfPaths ((18U << 16U) + 1U)
+#define sfBaseAsset ((26U << 16U) + 1U)
+#define sfQuoteAsset ((26U << 16U) + 2U)
+#define sfLockingChainIssue ((24U << 16U) + 1U)
+#define sfIssuingChainIssue ((24U << 16U) + 2U)
+#define sfAsset ((24U << 16U) + 3U)
+#define sfAsset2 ((24U << 16U) + 4U)
+#define sfClaimCurrency ((24U << 16U) + 5U)
+#define sfXChainBridge ((25U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
 #define sfDeletedNode ((14U << 16U) + 4U)
@@ -191,13 +287,33 @@
 #define sfEmitDetails ((14U << 16U) + 13U)
 #define sfHook ((14U << 16U) + 14U)
 #define sfSigner ((14U << 16U) + 16U)
+#define sfExportSigner ((14U << 16U) + 17U)
 #define sfMajority ((14U << 16U) + 18U)
 #define sfDisabledValidator ((14U << 16U) + 19U)
 #define sfEmittedTxn ((14U << 16U) + 20U)
 #define sfHookExecution ((14U << 16U) + 21U)
-#define sfHookDefinition ((14U << 16U) + 22U)
 #define sfHookParameter ((14U << 16U) + 23U)
 #define sfHookGrant ((14U << 16U) + 24U)
+#define sfVoteEntry ((14U << 16U) + 25U)
+#define sfAuctionSlot ((14U << 16U) + 26U)
+#define sfAuthAccount ((14U << 16U) + 27U)
+#define sfXChainClaimProofSig ((14U << 16U) + 28U)
+#define sfXChainCreateAccountProofSig ((14U << 16U) + 29U)
+#define sfXChainClaimAttestationCollectionElement ((14U << 16U) + 30U)
+#define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
+#define sfPriceData ((14U << 16U) + 32U)
+#define sfCredential ((14U << 16U) + 33U)
+#define sfExportedTxn ((14U << 16U) + 89U)
+#define sfManifest ((14U << 16U) + 90U)
+#define sfAmountEntry ((14U << 16U) + 91U)
+#define sfMintURIToken ((14U << 16U) + 92U)
+#define sfHookEmission ((14U << 16U) + 93U)
+#define sfImportVLKey ((14U << 16U) + 94U)
+#define sfActiveValidator ((14U << 16U) + 95U)
+#define sfGenesisMint ((14U << 16U) + 96U)
+#define sfRemark ((14U << 16U) + 97U)
+#define sfHighReward ((14U << 16U) + 98U)
+#define sfLowReward ((14U << 16U) + 99U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)
@@ -207,9 +323,23 @@
 #define sfMemos ((15U << 16U) + 9U)
 #define sfNFTokens ((15U << 16U) + 10U)
 #define sfHooks ((15U << 16U) + 11U)
+#define sfVoteSlots ((15U << 16U) + 12U)
 #define sfMajorities ((15U << 16U) + 16U)
 #define sfDisabledValidators ((15U << 16U) + 17U)
 #define sfHookExecutions ((15U << 16U) + 18U)
 #define sfHookParameters ((15U << 16U) + 19U)
 #define sfHookGrants ((15U << 16U) + 20U)
-#define sfActiveValidators ((15U << 16U) + 95U)
+#define sfXChainClaimAttestations ((15U << 16U) + 21U)
+#define sfXChainCreateAccountAttestations ((15U << 16U) + 22U)
+#define sfExportSigners ((15U << 16U) + 23U)
+#define sfPriceDataSeries ((15U << 16U) + 24U)
+#define sfAuthAccounts ((15U << 16U) + 25U)
+#define sfAuthorizeCredentials ((15U << 16U) + 26U)
+#define sfUnauthorizeCredentials ((15U << 16U) + 27U)
+#define sfAcceptedCredentials ((15U << 16U) + 28U)
+#define sfAmounts ((15U << 16U) + 92U)
+#define sfHookEmissions ((15U << 16U) + 93U)
+#define sfImportVLKeys ((15U << 16U) + 94U)
+#define sfActiveValidators ((15U << 16U) + 95U)
+#define sfGenesisMints ((15U << 16U) + 96U)
+#define sfRemarks ((15U << 16U) + 97U)

hook/ls_flags.h

@@ -56,6 +56,10 @@ enum ltURI_TOKEN {
 enum remarks {
     lsfImmutable = 1,
 };
+enum ltEXPORT_LATCH {
+    lsfExportXpopSeen = 0x00000001,
+    lsfExportCanceled = 0x00000002,
+};
 enum ltMPTOKEN_ISSUANCE {
     lsfMPTLocked = 0x00000001,
     lsfMPTCanLock = 0x00000002,

hook/macro.h

@@ -145,6 +145,10 @@ int out_len = 0;\
 #define SUB_OFFSET(x) ((int32_t)(x >> 32))
 #define SUB_LENGTH(x) ((int32_t)(x & 0xFFFFFFFFULL))
 
+#define ENTROPY_TIER(x) (((uint64_t)(x) >> 32U) & 0xFFU)
+#define ENTROPY_COUNT(x) (((uint64_t)(x) >> 16U) & 0xFFFFU)
+#define ENTROPY_DENOMINATOR(x) ((uint64_t)(x) & 0xFFFFU)
+
 #define BUFFER_EQUAL_20(buf1, buf2)\
     (\
         *(((uint64_t*)(buf1)) + 0) == *(((uint64_t*)(buf2)) + 0) &&\
@@ -378,4 +382,3 @@ int out_len = 0;\
 
 #endif
 
-

hook/sfcodes.h

@@ -9,6 +9,8 @@
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
 #define sfWasLockingChainSend ((16U << 16U) + 19U)
+#define sfSidecarType ((16U << 16U) + 20U)
+#define sfEntropyTier ((16U << 16U) + 21U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
@@ -22,6 +24,10 @@
 #define sfHookApiVersion ((1U << 16U) + 20U)
 #define sfHookStateScale ((1U << 16U) + 21U)
 #define sfLedgerFixType ((1U << 16U) + 22U)
+#define sfHookExportCount ((1U << 16U) + 98U)
+#define sfEntropyCount ((1U << 16U) + 99U)
+#define sfEntropyDenominator ((1U << 16U) + 100U)
+#define sfExportCount ((1U << 16U) + 101U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -105,6 +111,7 @@
 #define sfMPTAmount ((3U << 16U) + 26U)
 #define sfIssuerNode ((3U << 16U) + 27U)
 #define sfSubjectNode ((3U << 16U) + 28U)
+#define sfExportNode ((3U << 16U) + 29U)
 #define sfTouchCount ((3U << 16U) + 97U)
 #define sfAccountIndex ((3U << 16U) + 98U)
 #define sfAccountCount ((3U << 16U) + 99U)
@@ -152,6 +159,9 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
+#define sfExportSignatureHash ((5U << 16U) + 38U)
+#define sfExportCommitteeHash ((5U << 16U) + 39U)
+#define sfManifestID ((5U << 16U) + 91U)
 #define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfHookOnIncoming ((5U << 16U) + 94U)
 #define sfCron ((5U << 16U) + 95U)
@@ -189,6 +199,8 @@
 #define sfSignatureReward ((6U << 16U) + 29U)
 #define sfMinAccountCreateAmount ((6U << 16U) + 30U)
 #define sfLPTokenBalance ((6U << 16U) + 31U)
+#define sfExportCallbackFee ((6U << 16U) + 32U)
+#define sfTrustLineRewardAccumulator ((6U << 16U) + 99U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -220,6 +232,10 @@
 #define sfProvider ((7U << 16U) + 30U)
 #define sfMPTokenMetadata ((7U << 16U) + 31U)
 #define sfCredentialType ((7U << 16U) + 32U)
+#define sfEntropyContributors ((7U << 16U) + 33U)
+#define sfExportCommittee ((7U << 16U) + 34U)
+#define sfExportContributors ((7U << 16U) + 35U)
+#define sfHookName ((7U << 16U) + 97U)
 #define sfRemarkValue ((7U << 16U) + 98U)
 #define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
@@ -255,6 +271,7 @@
 #define sfIssuingChainIssue ((24U << 16U) + 2U)
 #define sfAsset ((24U << 16U) + 3U)
 #define sfAsset2 ((24U << 16U) + 4U)
+#define sfClaimCurrency ((24U << 16U) + 5U)
 #define sfXChainBridge ((25U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
@@ -270,6 +287,7 @@
 #define sfEmitDetails ((14U << 16U) + 13U)
 #define sfHook ((14U << 16U) + 14U)
 #define sfSigner ((14U << 16U) + 16U)
+#define sfExportSigner ((14U << 16U) + 17U)
 #define sfMajority ((14U << 16U) + 18U)
 #define sfDisabledValidator ((14U << 16U) + 19U)
 #define sfEmittedTxn ((14U << 16U) + 20U)
@@ -285,6 +303,8 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
+#define sfExportedTxn ((14U << 16U) + 89U)
+#define sfManifest ((14U << 16U) + 90U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -292,6 +312,8 @@
 #define sfActiveValidator ((14U << 16U) + 95U)
 #define sfGenesisMint ((14U << 16U) + 96U)
 #define sfRemark ((14U << 16U) + 97U)
+#define sfHighReward ((14U << 16U) + 98U)
+#define sfLowReward ((14U << 16U) + 99U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)
@@ -309,6 +331,7 @@
 #define sfHookGrants ((15U << 16U) + 20U)
 #define sfXChainClaimAttestations ((15U << 16U) + 21U)
 #define sfXChainCreateAccountAttestations ((15U << 16U) + 22U)
+#define sfExportSigners ((15U << 16U) + 23U)
 #define sfPriceDataSeries ((15U << 16U) + 24U)
 #define sfAuthAccounts ((15U << 16U) + 25U)
 #define sfAuthorizeCredentials ((15U << 16U) + 26U)

hook/tts.h

@@ -61,6 +61,8 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
+#define ttEXPORT 90
+#define ttMANIFEST_SET 91
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94
@@ -74,3 +76,5 @@
 #define ttUNL_MODIFY 102
 #define ttEMIT_FAILURE 103
 #define ttUNL_REPORT 104
+#define ttCONSENSUS_ENTROPY 105
+#define ttEXPORT_SIGNATURES 106

hook/tx_flags.h

@@ -115,3 +115,10 @@ enum AMMClawbackFlags : uint32_t {
 enum BridgeModifyFlags : uint32_t {
     tfClearAccountCreateAmount = 0x00010000,
 };
+
+enum ExportFlags : uint32_t {
+    // Lifecycle control: erase the named latch and forfeit any later callback.
+    tfExportEraseLatch = 0x00010000,
+    // Committee control: erase the named immutable committee object.
+    tfExportEraseCommittee = 0x00020000,
+};

include/xrpl/hook/Enum.h

@@ -15,7 +15,10 @@
 #define uint256 std::string
 #define featureHooksUpdate1 "1"
 #define featureHooksUpdate2 "1"
+#define featureExport "1"
+#define featureConsensusEntropy "1"
 #define fix20250131 "1"
+#define fixGuardDepth32 "1"
 namespace hook_api {
 struct Rules
 {
@@ -264,11 +267,8 @@ enum hook_log_code : uint16_t {
     SECTIONS_OUT_OF_SEQUENCE =
         85,  // the wasm contained sections out of sequence
     CUSTOM_SECTION_DISALLOWED =
-        86,                // the wasm contained a custom section (id=0)
-    INTERNAL_ERROR = 87,   // an internal error described by the log text
-    JS_TEST_FAILURE = 88,  // smoke test of js bytecode failed
-    JS_FEE_MISSING = 89,
-    JS_FEE_OUT_OF_RANGE = 90,
+        86,               // the wasm contained a custom section (id=0)
+    INTERNAL_ERROR = 87,  // an internal error described by the log text
     // RH NOTE: only HookSet msgs got log codes, possibly all Hook log lines
     // should get a code?
 };
@@ -322,7 +322,7 @@ namespace compare_mode {
 enum compare_mode : uint32_t { EQUAL = 1, LESS = 2, GREATER = 4 };
 }
 
-enum hook_return_code : int64_t {
+enum class hook_return_code : int64_t {
     SUCCESS =
         0,  // return codes > 0 are reserved for hook apis to return "success"
     OUT_OF_BOUNDS =
@@ -384,31 +384,26 @@ enum hook_return_code : int64_t {
     INVALID_KEY = -41,   // user supplied key was not valid
     NOT_A_STRING = -42,  // nul terminator missing from a string argument
     MEM_OVERLAP = -43,   // one or more specified buffers are the same memory
-    TOO_MANY_STATE_MODIFICATIONS = -44,  // more than 5000 modified state
+    TOO_MANY_STATE_MODIFICATIONS = -44,  // more than 256 modified state
                                          // entires in the combined hook chains
-    TOO_MANY_NAMESPACES = -45
+    TOO_MANY_NAMESPACES = -45,
+    EXPORT_FAILURE = -46,
+    TOO_MANY_EXPORTED_TXN = -47,
+    TOO_LITTLE_ENTROPY = -48,
 };
 
-enum ExitType : uint8_t {
+enum class ExitType : uint8_t {
     UNSET = 0,
     WASM_ERROR = 1,
     ROLLBACK = 2,
     ACCEPT = 3,
-    JSVM_ERROR = 4,
-    LEDGER_ERROR =
-        5,  // if the ledger contained for example a nonsense hookapi number
-    INSTRUCTION_LIMIT_REACHED = 6,
-};
-
-enum CodeType : uint8_t {
-    WASM = 0,
-    JS = 1,
 };
 
 const uint16_t max_state_modifications = 256;
 const uint8_t max_slots = 255;
 const uint8_t max_nonce = 255;
 const uint8_t max_emit = 255;
+const uint8_t max_export = 2;
 const uint8_t max_params = 16;
 const double fee_base_multiplier = 1.1f;
 
@@ -426,6 +421,7 @@ getImportWhitelist(Rules const& rules)
 #undef HOOK_API_DEFINITION
 
 #define int64_t 0x7EU
+#define uint64_t 0x7EU
 #define int32_t 0x7FU
 #define uint32_t 0x7FU
 
@@ -436,16 +432,13 @@ getImportWhitelist(Rules const& rules)
     if (AMENDMENT == uint256{} || rules.enabled(AMENDMENT)) \
         whitelist[#FUNCTION_NAME] = {                       \
             RETURN_TYPE, HOOK_WRAP_PARAMS PARAMS_TUPLE};
-#define JSHOOK_API_DEFINITION(                           \
-    RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, AMENDMENT) \
-    {                                                    \
-    }
 
 #include "hook_api.macro"
 
 #undef HOOK_API_DEFINITION
 #undef HOOK_WRAP_PARAMS
 #undef int64_t
+#undef uint64_t
 #undef int32_t
 #undef uint32_t
 #pragma pop_macro("HOOK_API_DEFINITION")
@@ -453,12 +446,9 @@ getImportWhitelist(Rules const& rules)
     return whitelist;
 }
 
-#undef HOOK_API_DEFINITION
-#undef I32
-#undef I64
-
 enum GuardRulesVersion : uint64_t {
     GuardRuleFix20250131 = 0x00000001,
+    GuardRuleDepth32 = 0x00000002,
 };
 
 inline uint64_t
@@ -467,6 +457,8 @@ getGuardRulesVersion(Rules const& rules)
     uint64_t version = 0;
     if (rules.enabled(fix20250131))
         version |= GuardRuleFix20250131;
+    if (rules.enabled(fixGuardDepth32))
+        version |= GuardRuleDepth32;
     return version;
 }
 

include/xrpl/hook/Guard.h

@@ -204,9 +204,13 @@ struct WasmBlkInf
     }
 // compute worst case execution time
 inline uint64_t
-compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
+compute_wce(
+    const WasmBlkInf* blk,
+    int level,
+    int max_level,
+    bool* recursion_limit_reached)
 {
-    if (level > 16)
+    if (level > max_level)
     {
         *recursion_limit_reached = true;
         return 0;
@@ -233,8 +237,8 @@ compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
 
     if (blk->children.size() > 0)
         for (auto const& child : blk->children)
-            worst_case_execution +=
-                compute_wce(child, level + 1, recursion_limit_reached);
+            worst_case_execution += compute_wce(
+                child, level + 1, max_level, recursion_limit_reached);
 
     if (parent == 0 ||
         parent->iteration_bound ==
@@ -788,12 +792,17 @@ check_guard(
     }
 
     bool recursion_limit_reached = false;
-    uint64_t wce = compute_wce(&(*root), 0, &recursion_limit_reached);
+    int max_level = 16;
+    if (rulesVersion & hook_api::GuardRuleDepth32)
+        max_level = 32;
+    uint64_t wce =
+        compute_wce(&(*root), 0, max_level, &recursion_limit_reached);
     if (recursion_limit_reached)
     {
         GUARDLOG(hook::log::NESTING_LIMIT)
             << "GuardCheck "
-            << "Maximum allowable depth of blocks reached (16 levels). Flatten "
+            << "Maximum allowable depth of blocks reached (" << max_level
+            << " levels). Flatten "
                "your loops and conditions!.\n";
         return {};
     }

include/xrpl/hook/Macro.h

@@ -67,7 +67,6 @@
 #define SEP_int32_t LPAREN int32_t COMMA
 #define SEP_uint64_t LPAREN uint64_t COMMA
 #define SEP_int64_t LPAREN int64_t COMMA
-#define SEP_JSValue LPAREN JSValue COMMA
 
 #define VAL_uint32_t WasmEdge_ValueGetI32(in[_stack++])
 #define VAL_int32_t WasmEdge_ValueGetI32(in[_stack++])
@@ -90,174 +89,69 @@
 
 #define WASM_VAL_TYPE(T, b) CAT2(TYP_, T)
 
-#define HALF_COUNT(...) \
-    HALF_COUNT_IMPL(    \
-        __VA_ARGS__,    \
-        16,             \
-        16,             \
-        15,             \
-        15,             \
-        14,             \
-        14,             \
-        13,             \
-        13,             \
-        12,             \
-        12,             \
-        11,             \
-        11,             \
-        10,             \
-        10,             \
-        9,              \
-        9,              \
-        8,              \
-        8,              \
-        7,              \
-        7,              \
-        6,              \
-        6,              \
-        5,              \
-        5,              \
-        4,              \
-        4,              \
-        3,              \
-        3,              \
-        2,              \
-        2,              \
-        1,              \
-        1,              \
-        0,              \
-        0)
+#define UNSIGNED_TYPE(T) std::make_unsigned_t<T>
 
-#define HALF_COUNT_IMPL( \
-    _1,                  \
-    _2,                  \
-    _3,                  \
-    _4,                  \
-    _5,                  \
-    _6,                  \
-    _7,                  \
-    _8,                  \
-    _9,                  \
-    _10,                 \
-    _11,                 \
-    _12,                 \
-    _13,                 \
-    _14,                 \
-    _15,                 \
-    _16,                 \
-    _17,                 \
-    _18,                 \
-    _19,                 \
-    _20,                 \
-    _21,                 \
-    _22,                 \
-    _23,                 \
-    _24,                 \
-    _25,                 \
-    _26,                 \
-    _27,                 \
-    _28,                 \
-    _29,                 \
-    _30,                 \
-    _31,                 \
-    _32,                 \
-    N,                   \
-    ...)                 \
-    N
-
-#define DECLARE_WASM_FUNCTION(R, F, ...)                         \
-    R F(hook::HookContext& hookCtx,                              \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__( \
-            COMMA __VA_ARGS__));                                 \
-    extern WasmEdge_Result WasmFunction##F(                      \
-        void* data_ptr,                                          \
-        const WasmEdge_CallingFrameContext* frameCtx,            \
-        const WasmEdge_Value* in,                                \
-        WasmEdge_Value* out);                                    \
-    extern WasmEdge_ValType WasmFunctionParams##F[];             \
-    extern WasmEdge_ValType WasmFunctionResult##F[];             \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;    \
+#define DECLARE_HOOK_FUNCTION(R, F, ...)                          \
+    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> F( \
+        hook::HookContext& hookCtx,                               \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(  \
+            COMMA __VA_ARGS__));                                  \
+    extern WasmEdge_Result WasmFunction##F(                       \
+        void* data_ptr,                                           \
+        const WasmEdge_CallingFrameContext* frameCtx,             \
+        const WasmEdge_Value* in,                                 \
+        WasmEdge_Value* out);                                     \
+    extern WasmEdge_ValType WasmFunctionParams##F[];              \
+    extern WasmEdge_ValType WasmFunctionResult##F[];              \
+    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;     \
     extern WasmEdge_String WasmFunctionName##F;
 
-#define DECLARE_JS_FUNCTION(R, F, ...)                                        \
-    extern JSValue JSFunction##F(                                             \
-        JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv); \
-    const int JSFunctionParamCount##F = __VA_OPT__(HALF_COUNT(__VA_ARGS__) +) 0;
-
-#define DEFINE_WASM_FUNCTION(R, F, ...)                             \
-    WasmEdge_Result hook_api::WasmFunction##F(                      \
-        void* data_ptr,                                             \
-        const WasmEdge_CallingFrameContext* frameCtx,               \
-        const WasmEdge_Value* in,                                   \
-        WasmEdge_Value* out)                                        \
-    {                                                               \
-        __VA_OPT__(int _stack = 0;)                                 \
-        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)           \
-        hook::HookContext* hookCtx =                                \
-            reinterpret_cast<hook::HookContext*>(data_ptr);         \
-        R return_code = hook_api::F(                                \
-            *hookCtx,                                               \
-            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)    \
-                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));        \
-        if (return_code == RC_ROLLBACK || return_code == RC_ACCEPT) \
-            return WasmEdge_Result_Terminate;                       \
-        out[0] = RET_ASSIGN(R, return_code);                        \
-        return WasmEdge_Result_Success;                             \
-    };                                                              \
-    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {          \
-        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};       \
-    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {         \
-        WASM_VAL_TYPE(R, dummy)};                                   \
-    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =   \
-        WasmEdge_FunctionTypeCreate(                                \
-            WasmFunctionParams##F,                                  \
-            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),               \
-            WasmFunctionResult##F,                                  \
-            1);                                                     \
-    WasmEdge_String hook_api::WasmFunctionName##F =                 \
-        WasmEdge_StringCreateByCString(#F);                         \
-    R hook_api::F(                                                  \
-        hook::HookContext& hookCtx,                                 \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(    \
+#define DEFINE_HOOK_FUNCTION(R, F, ...)                                        \
+    WasmEdge_Result hook_api::WasmFunction##F(                                 \
+        void* data_ptr,                                                        \
+        const WasmEdge_CallingFrameContext* frameCtx,                          \
+        const WasmEdge_Value* in,                                              \
+        WasmEdge_Value* out)                                                   \
+    {                                                                          \
+        __VA_OPT__(int _stack = 0;)                                            \
+        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)                      \
+        hook::HookContext* hookCtx =                                           \
+            reinterpret_cast<hook::HookContext*>(data_ptr);                    \
+        auto const& return_code = hook_api::F(                                 \
+            *hookCtx,                                                          \
+            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)               \
+                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));                   \
+        if (std::holds_alternative<hook_api::hook_return_code>(return_code) && \
+            (std::get<hook_api::hook_return_code>(return_code) ==              \
+                 RC_ROLLBACK ||                                                \
+             std::get<hook_api::hook_return_code>(return_code) == RC_ACCEPT))  \
+            return WasmEdge_Result_Terminate;                                  \
+        out[0] = RET_ASSIGN(                                                   \
+            R,                                                                 \
+            std::holds_alternative<UNSIGNED_TYPE(R)>(return_code)              \
+                ? std::get<UNSIGNED_TYPE(R)>(return_code)                      \
+                : R(std::get<hook_api::hook_return_code>(return_code)));       \
+        return WasmEdge_Result_Success;                                        \
+    };                                                                         \
+    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {                     \
+        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};                  \
+    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {                    \
+        WASM_VAL_TYPE(R, dummy)};                                              \
+    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =              \
+        WasmEdge_FunctionTypeCreate(                                           \
+            WasmFunctionParams##F,                                             \
+            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),                          \
+            WasmFunctionResult##F,                                             \
+            1);                                                                \
+    WasmEdge_String hook_api::WasmFunctionName##F =                            \
+        WasmEdge_StringCreateByCString(#F);                                    \
+    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> hook_api::F(    \
+        hook::HookContext& hookCtx,                                            \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(               \
             COMMA __VA_ARGS__))
 
-#define VAR_JSASSIGN(T, V)          \
-    if (_stack >= argc)             \
-        returnJS(INVALID_ARGUMENT); \
-    T& V = argv[_stack++]
-
-#define FORWARD_JS_FUNCTION_CALL(F, ac, av) \
-    hook_api::JSFunction##F(ctx, this_val, ac, av)
-
-#define DEFINE_JS_FUNCTION(R, F, ...)                                        \
-    JSValue hook_api::JSFunction##F(                                         \
-        JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) \
-    {                                                                        \
-        __VA_OPT__(int _stack = 0;)                                          \
-        __VA_OPT__(FOR_VARS(VAR_JSASSIGN, 2, __VA_ARGS__);)
-
-#define JS_HOOK_SETUP()                                                 \
-    JSRuntime* rt = JS_GetRuntime(ctx);                                 \
-    hook::HookContext& hookCtx =                                        \
-        *reinterpret_cast<hook::HookContext*>(JS_GetRuntimeOpaque(rt)); \
-    [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;         \
-    [[maybe_unused]] auto& view = applyCtx.view();                      \
-    [[maybe_unused]] auto j = applyCtx.app.journal("View");             \
-    [[maybe_unused]] auto& api = hookCtx.api();                         \
-    try                                                                 \
-    {
-#define JS_HOOK_TEARDOWN()                                        \
-    }                                                             \
-    catch (const std::exception& e)                               \
-    {                                                             \
-        JLOG(hookCtx.applyCtx.app.journal("View").error())        \
-            << "HookError[" << HC_ACC() << "]: (JS) " << __func__ \
-            << " threw uncaught exception, what=" << e.what();    \
-        return JS_NewInt64(ctx, INTERNAL_ERROR);                  \
-    }                                                             \
-    }
-
-#define WASM_HOOK_SETUP()                                            \
+#define HOOK_SETUP()                                                 \
+    using enum hook_api::hook_return_code;                           \
     try                                                              \
     {                                                                \
         [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;  \
@@ -274,14 +168,14 @@
         if (!memoryCtx || !memory || !memory_length)                 \
             return INTERNAL_ERROR;
 
-#define WASM_HOOK_TEARDOWN()                                        \
-    }                                                               \
-    catch (const std::exception& e)                                 \
-    {                                                               \
-        JLOG(hookCtx.applyCtx.app.journal("View").error())          \
-            << "HookError[" << HC_ACC() << "]: (WASM) " << __func__ \
-            << " threw uncaught exception, what=" << e.what();      \
-        return INTERNAL_ERROR;                                      \
+#define HOOK_TEARDOWN()                                        \
+    }                                                          \
+    catch (const std::exception& e)                            \
+    {                                                          \
+        JLOG(hookCtx.applyCtx.app.journal("View").error())     \
+            << "HookError[" << HC_ACC() << "]: " << __func__   \
+            << " threw uncaught exception, what=" << e.what(); \
+        return INTERNAL_ERROR;                                 \
     }
 
 #define WRITE_WASM_MEMORY(                                                  \
@@ -320,7 +214,7 @@
     host_memory_ptr,                  \
     guest_memory_length)              \
     {                                 \
-        int64_t bytes_written = 0;    \
+        uint64_t bytes_written = 0;   \
         WRITE_WASM_MEMORY(            \
             bytes_written,            \
             guest_dst_ptr,            \
@@ -375,28 +269,6 @@
                                                     : RC_ROLLBACK);            \
     }
 
-#define HOOK_EXIT_JS(error_msg, error_code, exit_type)                      \
-    {                                                                       \
-        int64_t val = 0;                                                    \
-        if (JS_IsNumber(error_code))                                        \
-            JS_ToInt64(ctx, &val, error_code);                              \
-        hookCtx.result.exitCode = val;                                      \
-        hookCtx.result.exitType = exit_type;                                \
-        if (JS_IsString(error_msg))                                         \
-        {                                                                   \
-            size_t len;                                                     \
-            const char* cstr = JS_ToCStringLen(ctx, &len, error_msg);       \
-            if (len > 256)                                                  \
-                len = 256;                                                  \
-            hookCtx.result.exitReason = std::string(cstr, len);             \
-            JS_FreeCString(ctx, cstr);                                      \
-        }                                                                   \
-        return JS_Exit(                                                     \
-            ctx,                                                            \
-            exit_type == hook_api::ExitType::ACCEPT ? "HookExit Accept"     \
-                                                    : "HookExit Rollback"); \
-    }
-
 #define WRITE_WASM_MEMORY_OR_RETURN_AS_INT64(                            \
     write_ptr_in, write_len_in, data_ptr_in, data_len_in, is_account_in) \
     {                                                                    \
@@ -411,7 +283,7 @@
             data_ptr < (data_ptr_in))                                    \
             return INTERNAL_ERROR;                                       \
         if (data_len == 0)                                               \
-            return 0;                                                    \
+            return 0ULL;                                                 \
         if ((write_ptr_in) == 0)                                         \
             return data_as_int64(data_ptr, data_len);                    \
         if (data_len > (write_len_in))                                   \

include/xrpl/hook/hook_api.macro

@@ -7,559 +7,311 @@ HOOK_API_DEFINITION(
 HOOK_API_DEFINITION(
   int64_t, accept, (uint32_t, uint32_t, int64_t),
   uint256{})
-// function accept(error_msg: string, error_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, accept, (JSValue, JSValue),
-  uint256{})
 
 // int64_t rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
 HOOK_API_DEFINITION(
   int64_t, rollback, (uint32_t, uint32_t, int64_t),
   uint256{})
-// function rollback(error_msg: string, error_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, rollback, (JSValue, JSValue),
-  uint256{})
 
 // int64_t util_raddr(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_raddr, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_raddr(acc_id:string): string
-JSHOOK_API_DEFINITION(
-  JSValue, util_raddr, (JSValue),
-  uint256{})
 
 // int64_t util_accid(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_accid, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_accid(acc_id:string): string
-JSHOOK_API_DEFINITION(
-  JSValue, util_accid, (JSValue),
-  uint256{})
 
 // int64_t util_verify(uint32_t dread_ptr, uint32_t dread_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, util_verify, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_verify(data:string, sig: string, pubkey: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_verify, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t util_sha512h(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_sha512h, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_sha512h(data: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_sha512h, (JSValue),
-  uint256{})
 
 // int64_t util_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t keylet_type, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f);
 HOOK_API_DEFINITION(
   int64_t, util_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_keylet(keylet_type: number, keylet_data: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_keylet, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_validate(uint32_t tread_ptr, uint32_t tread_len);
 HOOK_API_DEFINITION(
   int64_t, sto_validate, (uint32_t, uint32_t),
   uint256{})
-// function sto_validate(sto: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_validate, (JSValue),
-  uint256{})
 
 // int64_t sto_subfield(uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_subfield(sto: string, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_subfield, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_subarray(uint32_t read_ptr, uint32_t read_len, uint32_t array_id);
 HOOK_API_DEFINITION(
   int64_t, sto_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_subarray(sto: string, array_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_subarray, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_emplace(uint32_t write_ptr, uint32_t write_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t fread_ptr, uint32_t fread_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_emplace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_emplace(sto: string, field_bytes: number, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_emplace, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_erase(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_erase, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_erase(sto: string, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_erase, (JSValue, JSValue),
-  uint256{})
 
 // int64_t etxn_burden();
 HOOK_API_DEFINITION(
   int64_t, etxn_burden, (),
   uint256{})
-// function etxn_burden(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_burden, (),
-  uint256{})
 
 // int64_t etxn_details(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_details, (uint32_t, uint32_t),
   uint256{})
-// function etxn_details(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_details, (),
-  uint256{})
 
 // int64_t etxn_fee_base(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_fee_base, (uint32_t, uint32_t),
   uint256{})
-// function etxn_fee_base(txblob: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_fee_base, (JSValue),
-  uint256{})
 
 // int64_t etxn_reserve(uint32_t count);
 HOOK_API_DEFINITION(
   int64_t, etxn_reserve, (uint32_t),
   uint256{})
-// function etxn_reserve(count: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_reserve, (JSValue),
-  uint256{})
 
 // int64_t etxn_generation();
 HOOK_API_DEFINITION(
   int64_t, etxn_generation, (),
   uint256{})
-// function etxn_generation(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_generation, (),
-  uint256{})
 
 // int64_t etxn_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_nonce, (uint32_t, uint32_t),
   uint256{})
-// function etxn_nonce(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_nonce, (),
-  uint256{})
 
 // int64_t emit(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, emit, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function emit(txn: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, emit, (JSValue),
-  uint256{})
 
 // int64_t float_set(int32_t exponent, int64_t mantissa);
 HOOK_API_DEFINITION(
   int64_t, float_set, (int32_t, int64_t),
   uint256{})
-// function float_set(e: number, m: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_multiply(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_multiply, (int64_t, int64_t),
   uint256{})
-// function float_multiply(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_multiply, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_mulratio(int64_t float1, uint32_t round_up, uint32_t numerator, uint32_t denominator);
 HOOK_API_DEFINITION(
   int64_t, float_mulratio, (int64_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function float_mulratio(f1: number, round_up: number, numerator: number, denominator: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_mulratio, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_negate(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_negate, (int64_t),
   uint256{})
-// function float_negate(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_negate, (JSValue),
-  uint256{})
 
 // int64_t float_compare(int64_t float1, int64_t float2, uint32_t mode);
 HOOK_API_DEFINITION(
   int64_t, float_compare, (int64_t, int64_t, uint32_t),
   uint256{})
-// function float_compare(f1: number, f2: number, mode: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_compare, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sum(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_sum, (int64_t, int64_t),
   uint256{})
-// function float_sum(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sum, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sto(uint32_t write_ptr, uint32_t write_len, uint32_t cread_ptr, uint32_t cread_len, uint32_t iread_ptr, uint32_t iread_len, int64_t float1, uint32_t field_code);
 HOOK_API_DEFINITION(
   int64_t, float_sto, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int64_t, uint32_t),
   uint256{})
-// function float_sto(cur: string, isu: string, float1: number, field_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sto, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sto_set(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, float_sto_set, (uint32_t, uint32_t),
   uint256{})
-// function float_sto_set(buf: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sto_set, (JSValue),
-  uint256{})
 
 // int64_t float_invert(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_invert, (int64_t),
   uint256{})
-// function float_invert(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_invert, (JSValue),
-  uint256{})
 
 // int64_t float_divide(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_divide, (int64_t, int64_t),
   uint256{})
-// function float_divide(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_divide, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_one();
 HOOK_API_DEFINITION(
   int64_t, float_one, (),
   uint256{})
-// function float_one(): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_one, (),
-  uint256{})
 
 // int64_t float_mantissa(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_mantissa, (int64_t),
   uint256{})
-// function float_mantissa(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_mantissa, (JSValue),
-  uint256{})
 
 // int64_t float_sign(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_sign, (int64_t),
   uint256{})
-// function float_sign(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sign, (JSValue),
-  uint256{})
 
 // int64_t float_int(int64_t float1, uint32_t decimal_places, uint32_t abs);
 HOOK_API_DEFINITION(
   int64_t, float_int, (int64_t, uint32_t, uint32_t),
   uint256{})
-// function float_int(f1: number, decimal_places: number, abs: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_int, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_log(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_log, (int64_t),
   uint256{})
-// function float_log(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_log, (JSValue),
-  uint256{})
 
 // int64_t float_root(int64_t float1, uint32_t n);
 HOOK_API_DEFINITION(
   int64_t, float_root, (int64_t, uint32_t),
   uint256{})
-// function float_root(f1: number, n: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_root, (JSValue, JSValue),
-  uint256{})
 
 // int64_t fee_base();
 HOOK_API_DEFINITION(
   int64_t, fee_base, (),
   uint256{})
-// function fee_base(): number
-JSHOOK_API_DEFINITION(
-  JSValue, fee_base, (),
-  uint256{})
 
 // int64_t ledger_seq();
 HOOK_API_DEFINITION(
   int64_t, ledger_seq, (),
   uint256{})
-// function ledger_seq(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_seq, (),
-  uint256{})
 
 // int64_t ledger_last_time();
 HOOK_API_DEFINITION(
   int64_t, ledger_last_time, (),
   uint256{})
-// function ledger_last_time(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_last_time, (),
-  uint256{})
 
 // int64_t ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_last_hash, (uint32_t, uint32_t),
   uint256{})
-// function ledger_last_hash(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_last_hash, (),
-  uint256{})
 
 // int64_t ledger_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_nonce, (uint32_t, uint32_t),
   uint256{})
-// function ledger_nonce(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_nonce, (),
-  uint256{})
 
 // int64_t ledger_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t lread_ptr, uint32_t lread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function ledger_keylet(low: string, high: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_keylet, (JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_account(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, hook_account, (uint32_t, uint32_t),
   uint256{})
-// function hook_account(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_account, (),
-  uint256{})
 
 // int64_t hook_hash(uint32_t write_ptr, uint32_t write_len, int32_t hook_no);
 HOOK_API_DEFINITION(
   int64_t, hook_hash, (uint32_t, uint32_t, int32_t),
   uint256{})
-// function hook_hash(hook_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_hash, (JSValue),
-  uint256{})
 
 // int64_t hook_param_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
   int64_t, hook_param_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_param_set(value: string, key: string, hash: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_param_set, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, hook_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_param(key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_param, (JSValue),
-  uint256{})
 
 // int64_t hook_again();
 HOOK_API_DEFINITION(
   int64_t, hook_again, (),
   uint256{})
-// function hook_again(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_again, (),
-  uint256{})
 
 // int64_t hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, hook_skip, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_skip(hhash: string, flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_skip, (JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_pos();
 HOOK_API_DEFINITION(
   int64_t, hook_pos, (),
   uint256{})
-// function hook_pos(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_pos, (),
-  uint256{})
 
 // int64_t slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot, (JSValue),
-  uint256{})
 
 // int64_t slot_clear(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_clear, (uint32_t),
   uint256{})
-// function slot_clear(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_clear, (JSValue),
-  uint256{})
 
 // int64_t slot_count(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_count, (uint32_t),
   uint256{})
-// function slot_count(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_count, (JSValue),
-  uint256{})
 
 // int64_t slot_set(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_set, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_set(kl: string, slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_size(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_size, (uint32_t),
   uint256{})
-// function slot_size(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_size, (JSValue),
-  uint256{})
 
 // int64_t slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
   int64_t, slot_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_subarray(parent_slot_no: number, array_id: number, new_slot: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_subarray, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
   int64_t, slot_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_subfield(parent_slot_no: number, field_id: number, new_slot: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_subfield, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_type(uint32_t slot_no, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, slot_type, (uint32_t, uint32_t),
   uint256{})
-// function slot_type(slot_no: number, flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_type, (JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_float(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, slot_float, (uint32_t),
   uint256{})
-// function slot_float(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_float, (JSValue),
-  uint256{})
 
 // int64_t state_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, state_set, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_set(val: string, key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t state_foreign_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
   int64_t, state_foreign_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_foreign_set(val: string, key: string, ns: string, accid: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_foreign_set, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t state(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, state, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state(key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state, (JSValue),
-  uint256{})
 
 // int64_t state_foreign(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
   int64_t, state_foreign, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_foreign(key: string, ns: string, accid: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_foreign, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t trace(uint32_t mread_ptr, uint32_t mread_len, uint32_t dread_ptr, uint32_t dread_len, uint32_t as_hex);
 HOOK_API_DEFINITION(
   int64_t, trace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function trace(msg: string, data: string, as_hex: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, trace, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t trace_num(uint32_t read_ptr, uint32_t read_len, int64_t number);
 HOOK_API_DEFINITION(
@@ -575,108 +327,78 @@ HOOK_API_DEFINITION(
 HOOK_API_DEFINITION(
   int64_t, otxn_burden, (),
   uint256{})
-// function otxn_burden(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_burden, (),
-  uint256{})
 
 // int64_t otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, otxn_field, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_field(field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_field, (JSValue),
-  uint256{})
 
 // int64_t otxn_generation();
 HOOK_API_DEFINITION(
   int64_t, otxn_generation, (),
   uint256{})
-// function otxn_generation(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_generation, (),
-  uint256{})
 
 // int64_t otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, otxn_id, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_id(flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_id, (JSValue),
-  uint256{})
 
 // int64_t otxn_type();
 HOOK_API_DEFINITION(
   int64_t, otxn_type, (),
   uint256{})
-// function otxn_type(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_type, (),
-  uint256{})
 
 // int64_t otxn_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, otxn_slot, (uint32_t),
   uint256{})
-// function otxn_slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_slot, (JSValue),
-  uint256{})
 
 // int64_t otxn_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, otxn_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_param(param_key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_param, (JSValue),
-  uint256{})
 
 // int64_t meta_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, meta_slot, (uint32_t),
   uint256{})
-// function meta_slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, meta_slot, (JSValue),
-  uint256{})
 
 // int64_t xpop_slot(uint32_t slot_no_tx, uint32_t slot_no_meta);
 HOOK_API_DEFINITION(
   int64_t, xpop_slot, (uint32_t, uint32_t),
   featureHooksUpdate1)
-// function xpop_slot(slot_no_tx: number, slot_no_meta: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, xpop_slot, (JSValue, JSValue),
-  uint256{})
 
 // int64_t prepare(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, prepare, (uint32_t, uint32_t, uint32_t, uint32_t),
   featureHooksUpdate2)
-// function prepare(tmpl: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, prepare, (JSValue),
-  uint256{})
 
-// function otxn_json(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_json, (),
-  uint256{})
+// int64_t xport_reserve(uint32_t count);
+HOOK_API_DEFINITION(
+  int64_t, xport_reserve, (uint32_t),
+  featureExport)
 
-// function slot_json(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_json, (JSValue),
-  uint256{})
+// int64_t xport(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t committee_hash_ptr, uint32_t committee_hash_len, uint64_t callback_fee_drops);
+HOOK_API_DEFINITION(
+  int64_t, xport, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint64_t),
+  featureExport)
 
-// function sto_to_json(sto_in: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_to_json, (JSValue),
-  uint256{})
+// int64_t xport_cancel(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
+HOOK_API_DEFINITION(
+  int64_t, xport_cancel, (uint32_t, uint32_t, uint32_t),
+  featureExport)
 
-// function sto_from_json(json_in: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_from_json, (JSValue),
-  uint256{})
+// int64_t entropy_cr_dice(uint32_t sides, uint32_t min_tier);
+HOOK_API_DEFINITION(
+  int64_t, entropy_cr_dice, (uint32_t, uint32_t),
+  featureConsensusEntropy)
+
+// int64_t entropy_cr_random(uint32_t write_ptr, uint32_t write_len, uint32_t min_tier);
+HOOK_API_DEFINITION(
+  int64_t, entropy_cr_random, (uint32_t, uint32_t, uint32_t),
+  featureConsensusEntropy)
+
+// int64_t entropy_cr_status(void);
+HOOK_API_DEFINITION(
+  int64_t, entropy_cr_status, (),
+  featureConsensusEntropy)

include/xrpl/proto/.clang-format

@@ -0,0 +1,2 @@
+---
+DisableFormat: true

include/xrpl/proto/ripple.proto

@@ -27,6 +27,7 @@ enum MessageType
     mtREPLAY_DELTA_RESPONSE     = 60;
     mtHAVE_TRANSACTIONS         = 63;
     mtTRANSACTIONS              = 64;
+    mtEXPORT_SHARES             = 65;
 }
 
 // token, iterations, target, challenge = issue demand for proof of work
@@ -36,6 +37,7 @@ enum MessageType
 //------------------------------------------------------------------------------
 
 /* Provides the current ephemeral key for a validator. */
+//@@start opaque-self-verifying-overlay-artifact-precedent
 message TMManifest
 {
     // A Manifest object in the Ripple serialization format.
@@ -49,6 +51,7 @@ message TMManifests
     // The manifests sent when a peer first connects to another peer are `history`.
     optional bool history = 2 [deprecated=true];
 }
+//@@end opaque-self-verifying-overlay-artifact-precedent
 
 //------------------------------------------------------------------------------
 
@@ -118,6 +121,15 @@ message TMTransactions
     repeated TMTransaction transactions = 1;
 }
 
+// Canonical post-validation Export signature contributions. Receivers enforce
+// ExportLimits caps for entry count, each frame, aggregate frame payload, and
+// encoded protobuf size. The encoded-size cap includes protobuf tags and
+// length prefixes but excludes the overlay message header.
+message TMExportShares
+{
+    repeated bytes shares = 1;
+}
+
 
 enum NodeStatus
 {
@@ -153,7 +165,11 @@ message TMStatusChange
 message TMProposeSet
 {
     required uint32 proposeSeq          = 1;
-    required bytes currentTxHash        = 2;    // the hash of the ledger we are proposing
+    // Proposed transaction-set identity. Legacy/plain proposals carry the
+    // tx-set hash directly; ConsensusExtensions proposals carry a serialized
+    // ExtendedPosition whose first field is that tx-set hash, followed by
+    // signed RNG/Export sidecar fields.
+    required bytes currentTxHash        = 2;
     required bytes nodePubKey           = 3;
     required uint32 closeTime           = 4;
     required bytes signature            = 5;    // signature of above fields
@@ -166,6 +182,16 @@ message TMProposeSet
 
     // Number of hops traveled
     optional uint32 hops                = 12    [deprecated=true];
+
+    //@@start proposal-export-share-container-binding
+    // Canonical post-validation ExportShare frames authored by the proposing
+    // validator and re-advertised for anti-entropy. The proposal's
+    // ExtendedPosition includes a digest of this repeated field, so the exact
+    // frames are covered by the proposal signature. Each frame carries its
+    // version, owner, origin transaction, origin ledger sequence and hash,
+    // committee position, signing key, and multisign signature.
+    repeated bytes exportSignatures     = 13;
+    //@@end proposal-export-share-container-binding
 }
 
 enum TxSetStatus
@@ -384,4 +410,3 @@ message TMHaveTransactions
 {
     repeated bytes hashes = 1;
 }
-

include/xrpl/protocol/EntropyTier.h

@@ -0,0 +1,62 @@
+#ifndef RIPPLE_PROTOCOL_ENTROPY_TIER_H_INCLUDED
+#define RIPPLE_PROTOCOL_ENTROPY_TIER_H_INCLUDED
+
+#include <cstdint>
+
+namespace ripple {
+
+/// Which gate the ledger's entropy passed. Stored in sfEntropyTier (UINT8)
+/// on the ttCONSENSUS_ENTROPY pseudo-transaction and the ConsensusEntropy
+/// ledger entry.
+///
+/// EntropyCount says how many validators contributed; EntropyDenominator says
+/// how many active validators were in the ledger-anchored view for that
+/// non-fallback result; EntropyTier says which gate the result passed. Fallback
+/// entropy carries count=0/denominator=0 because no validator-derived
+/// denominator was accepted. Tier values are strength-ordered so consumers can
+/// gate with a numeric comparison (tier >= required).
+///
+/// RESIDUAL BIAS — applies to fallback, participant_aligned, and
+/// validator_quorum. This is a commit/reveal scheme: a validator can withhold
+/// its reveal until after observing peers' reveals, choosing between two
+/// outcomes (its contribution in vs. out) — up to one bit of influence per
+/// withholder, and colluding withholders near a threshold can instead force a
+/// downgrade to a lower tier. These tiers bound and *label* manipulation (it is
+/// observable and limited); they are NOT bias-resistant against a colluding
+/// validator minority. A hook that requires validator_full fails closed if any
+/// active validator withholds, trading availability for no selective-
+/// withholding slack.
+enum EntropyTier : std::uint8_t {
+    /// No usable entropy (reserved; a fresh ConsensusEntropy entry should
+    /// always carry one of the tiers below).
+    entropyTierNone = 0,
+
+    /// Consensus-bound deterministic fallback: derived from already-agreed
+    /// round inputs (parent ledger hash, base tx set hash, sequence) under
+    /// HashPrefix::entropyFallback when no agreed reveal set reaches either
+    /// participant_aligned or validator_quorum. Unpredictable in practice but
+    /// user-influenceable via transaction submission — never suitable for
+    /// value-bearing outcomes.
+    entropyTierConsensusFallback = 1,
+
+    /// Participant-aligned sub-quorum entropy: the agreed reveal set aligned at
+    /// the tier-2 participant threshold — below the 80% validator quorum but at
+    /// or above the equivocation-intersection floor over the original
+    /// (pre-nUNL)
+    /// view. Weaker than validator_quorum; opt-in for hooks via min_tier.
+    entropyTierParticipantAligned = 2,
+
+    /// Validator commit/reveal entropy whose sidecar set passed the
+    /// active-validator-view quorum alignment gate.
+    entropyTierValidatorQuorum = 3,
+
+    /// Validator commit/reveal entropy with reveals from every validator in
+    /// the ledger-anchored active view. Any missing active validator downgrades
+    /// the tier, so hooks can require this to fail closed on selective
+    /// withholding.
+    entropyTierValidatorFull = 4,
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/ExportCommittee.h

@@ -0,0 +1,131 @@
+#ifndef RIPPLE_PROTOCOL_EXPORTCOMMITTEE_H_INCLUDED
+#define RIPPLE_PROTOCOL_EXPORTCOMMITTEE_H_INCLUDED
+
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/ExportLimits.h>
+#include <xrpl/protocol/HashPrefix.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace ripple {
+
+/** One canonical, network-neutral Export validator committee. */
+struct ExportCommitteeProfile
+{
+    std::vector<PublicKey> members;
+    std::size_t quorum;
+
+    std::optional<std::uint16_t>
+    position(PublicKey const& master) const
+    {
+        auto const it =
+            std::lower_bound(members.begin(), members.end(), master);
+        if (it == members.end() || *it != master)
+            return std::nullopt;
+        return static_cast<std::uint16_t>(std::distance(members.begin(), it));
+    }
+};
+
+/** Parse a strictly sorted sequence of compressed validator master keys. */
+inline std::optional<ExportCommitteeProfile>
+resolveExportCommittee(Slice roster)
+{
+    constexpr std::size_t publicKeyBytes = 33;
+    if (roster.empty() || roster.size() % publicKeyBytes != 0)
+        return std::nullopt;
+
+    auto const count = roster.size() / publicKeyBytes;
+    if (count == 0 || count > ExportLimits::maxCommitteeMembers)
+        return std::nullopt;
+
+    std::vector<PublicKey> members;
+    members.reserve(count);
+    for (std::size_t offset = 0; offset < roster.size();
+         offset += publicKeyBytes)
+    {
+        Slice const encoded{roster.data() + offset, publicKeyBytes};
+        if (!publicKeyType(encoded))
+            return std::nullopt;
+
+        PublicKey member{encoded};
+        if (!members.empty() && !(members.back() < member))
+            return std::nullopt;
+        members.push_back(std::move(member));
+    }
+
+    return ExportCommitteeProfile{
+        std::move(members), ExportLimits::committeeQuorumThreshold(count)};
+}
+
+inline Blob
+serializeExportCommittee(std::vector<PublicKey> members)
+{
+    if (members.empty() || members.size() > ExportLimits::maxCommitteeMembers)
+        return {};
+
+    std::sort(members.begin(), members.end());
+    if (std::adjacent_find(members.begin(), members.end()) != members.end())
+        return {};
+
+    Blob roster;
+    roster.reserve(members.size() * 33);
+    for (auto const& member : members)
+        roster.insert(roster.end(), member.begin(), member.end());
+    return roster;
+}
+
+/** Canonicalize an unordered transaction roster into strict stored form. */
+inline std::optional<Blob>
+canonicalizeExportCommittee(Slice roster)
+{
+    constexpr std::size_t publicKeyBytes = 33;
+    if (roster.empty() || roster.size() % publicKeyBytes != 0)
+        return std::nullopt;
+
+    auto const count = roster.size() / publicKeyBytes;
+    if (count == 0 || count > ExportLimits::maxCommitteeMembers)
+        return std::nullopt;
+
+    std::vector<PublicKey> members;
+    members.reserve(count);
+    for (std::size_t offset = 0; offset < roster.size();
+         offset += publicKeyBytes)
+    {
+        Slice const encoded{roster.data() + offset, publicKeyBytes};
+        if (!publicKeyType(encoded))
+            return std::nullopt;
+        members.emplace_back(encoded);
+    }
+
+    auto canonical = serializeExportCommittee(std::move(members));
+    if (canonical.empty())
+        return std::nullopt;
+    return canonical;
+}
+
+/** Content identity of one already-validated canonical roster. */
+inline uint256
+exportCommitteeHash(Slice roster)
+{
+    auto const profile = resolveExportCommittee(roster);
+    if (!profile)
+        return {};
+
+    Serializer serialized;
+    serialized.add32(HashPrefix::exportCommittee);
+    serialized.add32(static_cast<std::uint32_t>(profile->members.size()));
+    serialized.addRaw(roster);
+    return serialized.getSHA512Half();
+}
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/ExportLimits.h

@@ -0,0 +1,119 @@
+#ifndef RIPPLE_PROTOCOL_EXPORT_LIMITS_H_INCLUDED
+#define RIPPLE_PROTOCOL_EXPORT_LIMITS_H_INCLUDED
+
+#include <xrpl/protocol/ValidatorBitset.h>
+
+#include <cstddef>
+#include <cstdint>
+
+namespace ripple {
+
+// Export system caps.
+//
+// These limits bound the DoS surface of the export signature system:
+// - Each selected validator signs once after exact source validation
+// - Pending shares are re-advertised through bounded proposal/relay batches
+// - Inbound signature processing involves crypto verification per sig
+// - Durable and per-message caps bound scans, crypto, and sidecar leaves
+struct ExportLimits
+{
+    // Ordinary XRPL multisigning accepts at most 32 signers. An account that
+    // reserves a separate operator signer must select fewer validators.
+    static constexpr std::size_t maxCommitteeMembers = 32;
+    static constexpr std::size_t maxCommitteeRosterBytes =
+        maxCommitteeMembers * 33;
+    static constexpr std::size_t maxCommitteeContributorBytes =
+        validatorBitsetBytes(maxCommitteeMembers);
+
+    // Export-specific serialized payload bounds. The release target includes
+    // the canonical origin Memo appended after validation; the witness wraps
+    // that target plus the accepted committee signatures.
+    static constexpr std::size_t maxExportReleaseTargetBytes = 2'048;
+    static constexpr std::size_t maxExportWitnessBytes = 8'192;
+
+    // V1 witnesses require the standard 80% quorum of the intent-selected
+    // committee, rounded up. The intent selects members but cannot lower this
+    // threshold. Split quotient/remainder arithmetic avoids overflow while
+    // preserving ceil(memberCount * 0.8).
+    static constexpr std::size_t
+    committeeQuorumThreshold(std::size_t memberCount)
+    {
+        auto const quotient = memberCount / 5;
+        auto const remainder = memberCount % 5;
+        return quotient * 4 + (remainder * 4 + 4) / 5;
+    }
+
+    // Maximum exports a single hook execution may produce. Hook API ABI
+    // constant hook_api::max_export must stay equal.
+    static constexpr std::uint8_t maxExportsPerHook = 2;
+
+    // Maximum Export intents admitted in one ledger and maximum live latches
+    // owned by one account.
+    static constexpr std::uint8_t maxPendingExports = 8;
+
+    // Global pending-latch and per-validation scan bound. Witnessed or canceled
+    // latches release this signing-work slot while their account owner count
+    // and reserve continue to bound retained state. This is a provisional
+    // activation tuning value.
+    static constexpr std::uint16_t maxLiveExportLatches = 64;
+
+    // Maximum admission window requested through the mandatory outer
+    // LastLedgerSequence. This bounds how long an Export may remain queued
+    // before entering a ledger; it does not bound post-validation release.
+    static constexpr std::uint32_t maxAdmissionWindowLedgers = 5;
+
+    // Fixed source-ledger window for post-validation share publication and
+    // witness materialization, measured from the ledger that admits the
+    // intent. This is a provisional activation tuning value. Keeping it
+    // separate from the outer LastLedgerSequence prevents queue delay from
+    // consuming the publication window.
+    static constexpr std::uint32_t maxPublicationLedgers = 5;
+
+    // A fully-canonical secp256k1 signature is at most 72 bytes; Ed25519 is 64.
+    static constexpr std::size_t maxCanonicalExportSignatureBytes = 72;
+
+    // Export-signature sidecar leaves encode an origin, committee position,
+    // signing key, and signature in an STObject envelope. Keep this comfortably
+    // above the canonical encoding while bounding peer-supplied leaf bytes
+    // before parse/hash work.
+    static constexpr std::size_t maxExportSignatureSidecarBytes = 256;
+
+    // Post-validation relay framing. Values are deliberately conservative
+    // local tuning knobs and require measurement before activation; changing
+    // them does not change the canonical per-share format.
+    // version + AccountID + 2 hashes + ledger sequence + committee position +
+    // compressed public key + one-byte VL prefix + maximum signature.
+    static constexpr std::size_t maxSerializedExportShareBytes =
+        1 + 20 + 32 + 4 + 32 + 2 + 33 + 1 + maxCanonicalExportSignatureBytes;
+    static constexpr std::size_t maxExportSharesPerRelay = 32;
+    static constexpr std::size_t maxExportShareRelayPayloadBytes =
+        maxSerializedExportShareBytes * maxExportSharesPerRelay;
+    // Protobuf repeated-bytes framing is one tag byte plus a two-byte varint
+    // length for every maximum-size frame. This excludes the overlay header.
+    static constexpr std::size_t maxExportShareRelayMessageBytes =
+        maxExportShareRelayPayloadBytes + 3 * maxExportSharesPerRelay;
+
+    // Provisional activation fee schedule. These values intentionally price
+    // Export intents above ordinary transactions until production measurements
+    // can replace the conservative work and storage estimates.
+    //
+    // Witness bytes are estimated from the exact serialized target size, a
+    // fixed allowance for the witness envelope/origin stamp/contributor mask,
+    // and one bounded signer entry for every selected member. The accepted
+    // sidecar witness retains every valid committee contribution, not merely
+    // the minimum quorum subset.
+    static constexpr std::uint64_t feeWitnessFixedAllowanceBytes = 384;
+    static constexpr std::uint64_t feeWitnessSignerAllowanceBytes = 128;
+    static constexpr std::uint64_t feeSharePublicationRounds =
+        maxPublicationLedgers + 1;
+    static constexpr std::uint64_t feeWorkUnitsPerSharePublication = 1;
+    static constexpr std::uint64_t feeWorkUnitsPerWitnessSignature = 2;
+    static constexpr std::uint64_t feeWitnessChunkBytes = 256;
+    static constexpr std::uint64_t feeWorkUnitsPerWitnessChunk = 1;
+    static constexpr std::uint64_t feePermanentWitnessByteDrops = 1;
+    static constexpr std::uint64_t feeSurchargeRoundDrops = 1'000;
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/ExportOriginMemo.h

@@ -0,0 +1,104 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+    IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_PROTOCOL_EXPORTORIGINMEMO_H_INCLUDED
+#define RIPPLE_PROTOCOL_EXPORTORIGINMEMO_H_INCLUDED
+
+#include <xrpl/basics/Expected.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+namespace ripple::ExportOriginMemo {
+
+inline constexpr std::string_view memoType = "xahau/export";
+inline constexpr std::uint8_t version = 1;
+inline constexpr std::uint8_t allowedFlags = 0;
+inline constexpr std::size_t identityBytes = 42;
+inline constexpr std::size_t releaseBytes = 78;
+
+struct Origin
+{
+    std::uint32_t sourceDomain;
+    std::uint32_t targetDomain;
+    uint256 transactionHash;
+
+    bool
+    operator==(Origin const&) const = default;
+};
+
+struct Anchor
+{
+    LedgerIndex ledgerSequence;
+    uint256 ledgerHash;
+
+    bool
+    operator==(Anchor const&) const = default;
+};
+
+struct Stamp
+{
+    Origin origin;
+    std::optional<Anchor> anchor;
+
+    bool
+    operator==(Stamp const&) const = default;
+};
+
+enum class Error {
+    reservedMemoPresent,
+    reservedMemoMissing,
+    reservedMemoPosition,
+    malformedMemo,
+    unsupportedVersion,
+    unsupportedFlags,
+    localChecks
+};
+
+/** Return true when any Memo reserves the Export protocol MemoType. */
+bool
+hasReservedMemo(STTx const& tx);
+
+/** Append the canonical identity projection as the final Memo.
+
+    Existing Memos remain byte-identical and in their original order. This
+    function does not normalize transaction authorization fields; callers must
+    supply the canonical unsigned multisign base.
+*/
+Expected<STTx, Error>
+identityForm(STTx const& base, Origin const& origin);
+
+/** Append the canonical release projection as the final Memo. */
+Expected<STTx, Error>
+releaseForm(STTx const& base, Origin const& origin, Anchor const& anchor);
+
+/** Parse one canonical final Export Memo. */
+Expected<Stamp, Error>
+parse(STTx const& tx);
+
+/** Replace a canonical release projection with its identity projection. */
+Expected<STTx, Error>
+projectIdentity(STTx const& stamped);
+
+}  // namespace ripple::ExportOriginMemo
+
+#endif

include/xrpl/protocol/ExportShare.h

@@ -0,0 +1,142 @@
+#ifndef RIPPLE_PROTOCOL_EXPORTSHARE_H_INCLUDED
+#define RIPPLE_PROTOCOL_EXPORTSHARE_H_INCLUDED
+
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/ExportLimits.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/digest.h>
+
+#include <cstdint>
+#include <cstring>
+#include <optional>
+#include <stdexcept>
+
+namespace ripple {
+
+/** Canonical post-validation Export signature contribution.
+
+    The multisign signature authenticates the derived destination transaction.
+    The remaining fields are bounded lookup and release context which live
+    admission checks against the origin latch and local validated chain.
+*/
+struct ExportShare
+{
+    static constexpr std::uint8_t currentVersion = 1;
+
+    std::uint8_t version{currentVersion};
+    AccountID owner;
+    uint256 originTxn;
+    LedgerIndex originLedgerSeq{0};
+    uint256 originLedgerHash;
+    std::uint16_t committeePosition{0};
+    PublicKey signingKey;
+    Buffer signature;
+
+    bool
+    hasCanonicalSignature() const
+    {
+        auto const keyType = publicKeyType(signingKey);
+        if (!keyType)
+            return false;
+
+        auto const sig = Slice{signature.data(), signature.size()};
+        if (*keyType == KeyType::secp256k1)
+        {
+            auto const canonicality = ecdsaCanonicality(sig);
+            return canonicality &&
+                *canonicality == ECDSACanonicality::fullyCanonical;
+        }
+
+        // Full Ed25519 canonicality is enforced by cryptographic admission.
+        // The framing layer can still reject every impossible wire length.
+        return *keyType == KeyType::ed25519 && signature.size() == 64;
+    }
+
+    bool
+    validShape() const
+    {
+        return version == currentVersion && owner != beast::zero &&
+            !originTxn.isZero() && originLedgerSeq != 0 &&
+            !originLedgerHash.isZero() &&
+            committeePosition < ExportLimits::maxCommitteeMembers &&
+            hasCanonicalSignature();
+    }
+
+    Serializer
+    serialize() const
+    {
+        if (!validShape())
+            throw std::invalid_argument("invalid ExportShare shape");
+
+        Serializer result;
+        result.add8(version);
+        result.addBitString(owner);
+        result.addBitString(originTxn);
+        result.add32(originLedgerSeq);
+        result.addBitString(originLedgerHash);
+        result.add16(committeePosition);
+        result.addRaw(signingKey.slice());
+        result.addVL(signature);
+        return result;
+    }
+
+    uint256
+    wireHash() const
+    {
+        // Raw-wire suppression only. Routing context such as committeePosition
+        // is checked against validated state before relay and is not
+        // authenticated by the destination multisignature.
+        auto const bytes = serialize();
+        return sha512Half(bytes.slice());
+    }
+
+    static std::optional<ExportShare>
+    parse(Slice bytes)
+    {
+        if (bytes.empty() ||
+            bytes.size() > ExportLimits::maxSerializedExportShareBytes)
+            return std::nullopt;
+
+        try
+        {
+            SerialIter sit{bytes};
+            auto const version = sit.get8();
+            auto const owner = sit.getBitString<160, detail::AccountIDTag>();
+            auto const originTxn = sit.get256();
+            auto const originLedgerSeq = sit.get32();
+            auto const originLedgerHash = sit.get256();
+            auto const committeePosition = sit.get16();
+            auto const keySlice = sit.getSlice(33);
+            if (!publicKeyType(keySlice))
+                return std::nullopt;
+            PublicKey const signingKey{keySlice};
+            auto signature = sit.getVLBuffer();
+            if (!sit.empty())
+                return std::nullopt;
+
+            ExportShare result{
+                version,
+                owner,
+                originTxn,
+                originLedgerSeq,
+                originLedgerHash,
+                committeePosition,
+                signingKey,
+                std::move(signature)};
+            if (!result.validShape())
+                return std::nullopt;
+            return result;
+        }
+        catch (std::exception const&)
+        {
+            return std::nullopt;
+        }
+    }
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/Feature.h

@@ -33,35 +33,39 @@
  *
  * Steps required to add new features to the code:
  *
- * 1) In this file, increment `numFeatures` and add a uint256 declaration
- *    for the feature at the bottom
- * 2) Add a uint256 definition for the feature to the corresponding source
- *    file (Feature.cpp). Use `registerFeature` to create the feature with
- *    the feature's name, `Supported::no`, and `VoteBehavior::DefaultNo`. This
- *    should be the only place the feature's name appears in code as a string.
- * 3) Use the uint256 as the parameter to `view.rules.enabled()` to
- *    control flow into new code that this feature limits.
- * 4) If the feature development is COMPLETE, and the feature is ready to be
- *    SUPPORTED, change the `registerFeature` parameter to Supported::yes.
- * 5) When the feature is ready to be ENABLED, change the `registerFeature`
- *    parameter to `VoteBehavior::DefaultYes`.
- * In general, any newly supported amendments (`Supported::yes`) should have
- * a `VoteBehavior::DefaultNo` for at least one full release cycle. High
- * priority bug fixes can be an exception to this rule of thumb.
+ * 1) Add the appropriate XRPL_FEATURE or XRPL_FIX macro definition for the
+ *    feature to features.macro with the feature's name, `Supported::no`, and
+ *    `VoteBehavior::DefaultNo`.
+ *
+ * 2) Use the generated variable name as the parameter to `view.rules.enabled()`
+ *    to control flow into new code that this feature limits. (featureName or
+ *    fixName)
+ *
+ * 3) If the feature development is COMPLETE, and the feature is ready to be
+ *    SUPPORTED, change the macro parameter in features.macro to Supported::yes.
+ *
+ * 4) In general, any newly supported amendments (`Supported::yes`) should have
+ *    a `VoteBehavior::DefaultNo` indefinitely so that external governance can
+ *    make the decision on when to activate it. High priority bug fixes can be
+ *    an exception to this rule. In such cases, ensure the fix has been
+ *    clearly communicated to the community using appropriate channels,
+ *    then change the macro parameter in features.macro to
+ *    `VoteBehavior::DefaultYes`. The communication process is beyond
+ *    the scope of these instructions.
+ *
  *
  * When a feature has been enabled for several years, the conditional code
  * may be removed, and the feature "retired". To retire a feature:
- * 1) Remove the uint256 declaration from this file.
- * 2) MOVE the uint256 definition in Feature.cpp to the "retired features"
- *    section at the end of the file.
- * 3) CHANGE the name of the variable to start with "retired".
- * 4) CHANGE the parameters of the `registerFeature` call to `Supported::yes`
- *    and `VoteBehavior::DefaultNo`.
+ *
+ * 1) MOVE the macro definition in features.macro to the "retired features"
+ *    section at the end of the file, and change the macro to XRPL_RETIRE.
+ *
  * The feature must remain registered and supported indefinitely because it
- * still exists in the ledger, but there is no need to vote for it because
- * there's nothing to vote for. If it is removed completely from the code, any
- * instances running that code will get amendment blocked. Removing the
- * feature from the ledger is beyond the scope of these instructions.
+ * may exist in the Amendments object on ledger. There is no need to vote
+ * for it because there's nothing to vote for. If the feature definition is
+ * removed completely from the code, any instances running that code will get
+ * amendment blocked. Removing the feature from the ledger is beyond the scope
+ * of these instructions.
  *
  */
 
@@ -76,11 +80,32 @@ allAmendments();
 
 namespace detail {
 
+#pragma push_macro("XRPL_FEATURE")
+#undef XRPL_FEATURE
+#pragma push_macro("XRPL_FIX")
+#undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
+
+#define XRPL_FEATURE(name, supported, vote) +1
+#define XRPL_FIX(name, supported, vote) +1
+#define XRPL_RETIRE(name) +1
+
 // This value SHOULD be equal to the number of amendments registered in
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 116;
+static constexpr std::size_t numFeatures =
+    (0 +
+#include <xrpl/protocol/detail/features.macro>
+    );
+
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
+#undef XRPL_FIX
+#pragma pop_macro("XRPL_FIX")
+#undef XRPL_FEATURE
+#pragma pop_macro("XRPL_FEATURE")
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -320,12 +345,17 @@ foreachFeature(FeatureBitset bs, F&& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) extern uint256 const feature##name;
 #define XRPL_FIX(name, supported, vote) extern uint256 const fix##name;
+#define XRPL_RETIRE(name)
 
 #include <xrpl/protocol/detail/features.macro>
 
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE

include/xrpl/protocol/HashPrefix.h

@@ -96,6 +96,24 @@ enum class HashPrefix : std::uint32_t {
 
     /** Credentials signature */
     credential = detail::make_hash_prefix('C', 'R', 'D'),
+
+    /** consensus extension sidecar object */
+    sidecar = detail::make_hash_prefix('S', 'C', 'R'),
+
+    /** consensus diagnostic observed participant set */
+    observedParticipants = detail::make_hash_prefix('O', 'B', 'P'),
+
+    /** consensus-bound fallback entropy digest (Tier 1: derived from
+        already-agreed round inputs when no agreed reveal set reaches an
+        accepted validator-participant tier; never to be confused with
+        validator entropy) */
+    entropyFallback = detail::make_hash_prefix('E', 'F', 'B'),
+
+    /** consensus entropy transaction-ordering salt */
+    entropyTxnOrder = detail::make_hash_prefix('E', 'T', 'O'),
+
+    /** immutable Export committee roster */
+    exportCommittee = detail::make_hash_prefix('E', 'C', 'M'),
 };
 
 template <class Hasher>

include/xrpl/protocol/Import.h

@@ -454,6 +454,15 @@ getVLInfo(Json::Value const& xpop, beast::Journal const& j)
             << "Import: unl blob was not valid json (after base64 decoding)";
         return {};
     }
+    auto const isNonNegativeUInt = [](Json::Value const& value) {
+        return value.isUInt() || (value.isInt() && value.asInt() >= 0);
+    };
+    if (!list.isMember(jss::sequence) ||
+        !isNonNegativeUInt(list[jss::sequence]))
+    {
+        JLOG(j.warn()) << "Import: unl blob sequence was missing or negative";
+        return {};
+    }
     auto const sequence = list[jss::sequence].asUInt();
     auto const m = deserializeManifest(base64_decode(
         xpop[jss::validation][jss::unl][jss::manifest].asString()));

include/xrpl/protocol/Indexes.h

@@ -62,6 +62,22 @@ emittedDir() noexcept;
 Keylet
 emittedTxn(uint256 const& id) noexcept;
 
+/** Locate an Export latch by its permanent source issuance identity.
+
+    The source Export transaction ID is content-addressed and cannot be reused,
+    including after AccountDelete.
+*/
+Keylet
+exportLatch(AccountID const& account, uint256 const& originTxnHash) noexcept;
+
+/** Locate an immutable Export committee owned by an account. */
+Keylet
+exportCommittee(AccountID const& account, uint256 const& digest) noexcept;
+
+/** The fixed global directory of Export latches awaiting witness work. */
+Keylet const&
+pendingExports() noexcept;
+
 Keylet
 hookDefinition(uint256 const& hash) noexcept;
 
@@ -118,6 +134,10 @@ negativeUNL() noexcept;
 Keylet const&
 UNLReport() noexcept;
 
+/** The (fixed) index of the object containing consensus-derived entropy. */
+Keylet const&
+consensusEntropy() noexcept;
+
 /** The beginning of an order book */
 struct book_t
 {
@@ -372,6 +392,10 @@ permissionedDomain(AccountID const& account, std::uint32_t seq) noexcept;
 
 Keylet
 permissionedDomain(uint256 const& domainID) noexcept;
+
+Keylet
+manifest(PublicKey const& pk) noexcept;
+
 }  // namespace keylet
 
 // Everything below is deprecated and should be removed in favor of keylets:

include/xrpl/protocol/LedgerFormats.h

@@ -186,6 +186,10 @@ enum LedgerSpecificFlags {
     // remarks
     lsfImmutable = 1,
 
+    // ltEXPORT_LATCH
+    lsfExportXpopSeen = 0x00000001,
+    lsfExportCanceled = 0x00000002,
+
     // ltMPTOKEN_ISSUANCE
     lsfMPTLocked = 0x00000001, // Also used in ltMPTOKEN
     lsfMPTCanLock = 0x00000002,

include/xrpl/protocol/Protocol.h

@@ -43,6 +43,19 @@ std::size_t constexpr txMinSizeBytes = 10;
 /** Largest legal byte size of a transaction. */
 std::size_t constexpr txMaxSizeBytes = megabytes(1);
 
+/** Largest network ID whose transactions retain the legacy canonical form.
+
+    Transactions on these networks must omit sfNetworkID. Transactions on
+    networks with larger IDs must include sfNetworkID matching the network.
+ */
+std::uint32_t constexpr maxNetworkIDWithoutTxField = 1024;
+
+constexpr bool
+requiresTxNetworkID(std::uint32_t networkID)
+{
+    return networkID > maxNetworkIDWithoutTxField;
+}
+
 /** The maximum number of unfunded offers to delete at once */
 std::size_t constexpr unfundedOfferRemoveLimit = 1000;
 

include/xrpl/protocol/SidecarType.h

@@ -0,0 +1,21 @@
+#ifndef RIPPLE_PROTOCOL_SIDECAR_TYPE_H_INCLUDED
+#define RIPPLE_PROTOCOL_SIDECAR_TYPE_H_INCLUDED
+
+#include <cstdint>
+
+namespace ripple {
+
+/// Discriminator for sidecar set entries (SHAMap leaves used for
+/// consensus extension data: RNG commit/reveal, export signatures).
+///
+/// Stored in sfSidecarType (UINT8) on each STObject entry.
+/// Makes sidecar sets self-describing — no content-sniffing needed.
+enum SidecarType : std::uint8_t {
+    sidecarRngCommit = 1,
+    sidecarRngReveal = 2,
+    sidecarExportSig = 3,
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/TER.h

@@ -68,7 +68,10 @@ enum TELcodes : TERUnderlyingType {
     telNON_LOCAL_EMITTED_TXN,
     telIMPORT_VL_KEY_NOT_RECOGNISED,
     telCAN_NOT_QUEUE_IMPORT,
+    // Keep test-only sentinels before appended branch-local TEL codes so their
+    // numeric values do not move.
     telENV_RPC_FAILED,
+    telEXPORT_LATCH_REQUIRED,
 };
 
 //------------------------------------------------------------------------------
@@ -137,6 +140,7 @@ enum TEMcodes : TERUnderlyingType {
     temXCHAIN_BRIDGE_NONDOOR_OWNER,
     temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT,
     temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT,
+    temXCHAIN_TOO_MANY_ATTESTATIONS,  // RESERVED - not used
 
     temHOOK_DATA_TOO_LARGE,
     temEMPTY_DID,
@@ -193,6 +197,8 @@ enum TEFcodes : TERUnderlyingType {
     tefNONDIR_EMIT,
     tefIMPORT_BLACKHOLED,
     tefINVALID_LEDGER_FIX_TYPE,
+    tefPAST_MANIFEST_SEQ,
+    tefREVOKED_MANIFEST,
 };
 
 //------------------------------------------------------------------------------
@@ -362,7 +368,7 @@ enum TECcodes : TERUnderlyingType {
     tecARRAY_TOO_LARGE = 197,
     tecLOCKED = 198,
     tecBAD_CREDENTIALS = 199,
-    tecINVALID_HOOK_API_VERSION = 200,
+    tecEXPORT_COMMITTEE_UNAVAILABLE = 201,
     tecLAST_POSSIBLE_ENTRY = 255,
 };
 

include/xrpl/protocol/TxFlags.h

@@ -274,6 +274,17 @@ enum BridgeModifyFlags : uint32_t {
     tfClearAccountCreateAmount = 0x00010000,
 };
 constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
+
+// Export flags:
+enum ExportFlags : uint32_t {
+    // Lifecycle control: erase the named latch and forfeit any later callback.
+    tfExportEraseLatch = 0x00010000,
+    // Committee control: erase the named immutable committee object.
+    tfExportEraseCommittee = 0x00020000,
+};
+constexpr std::uint32_t tfExportMask =
+    ~(tfUniversal | tfExportEraseLatch | tfExportEraseCommittee);
+
 // clang-format on
 
 }  // namespace ripple

include/xrpl/protocol/TxMeta.h

@@ -176,7 +176,6 @@ private:
     std::optional<STAmount> mDelivered;
     std::optional<STArray> mHookExecutions;
     std::optional<STArray> mHookEmissions;
-
     STArray mNodes;
 };
 

include/xrpl/protocol/ValidatorBitset.h

@@ -0,0 +1,158 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright 2026 Xahau
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+    IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_PROTOCOL_VALIDATORBITSET_H_INCLUDED
+#define RIPPLE_PROTOCOL_VALIDATORBITSET_H_INCLUDED
+
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/Slice.h>
+
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <utility>
+
+namespace ripple {
+
+class ValidatedValidatorBitset
+{
+    Blob bitset_;
+    std::size_t memberCount_ = 0;
+    std::size_t selected_ = 0;
+
+    ValidatedValidatorBitset(
+        Slice bitset,
+        std::size_t memberCount,
+        std::size_t selected)
+        : bitset_(bitset.begin(), bitset.end())
+        , memberCount_(memberCount)
+        , selected_(selected)
+    {
+    }
+
+public:
+    ValidatedValidatorBitset(ValidatedValidatorBitset const&) = default;
+    ValidatedValidatorBitset&
+    operator=(ValidatedValidatorBitset const&) = default;
+
+    ValidatedValidatorBitset(ValidatedValidatorBitset&& other) noexcept
+        : bitset_(std::move(other.bitset_))
+        , memberCount_(other.memberCount_)
+        , selected_(other.selected_)
+    {
+        other.bitset_.clear();
+        other.memberCount_ = 0;
+        other.selected_ = 0;
+    }
+
+    ValidatedValidatorBitset&
+    operator=(ValidatedValidatorBitset&& other) noexcept
+    {
+        if (this != &other)
+        {
+            bitset_ = std::move(other.bitset_);
+            memberCount_ = other.memberCount_;
+            selected_ = other.selected_;
+
+            other.bitset_.clear();
+            other.memberCount_ = 0;
+            other.selected_ = 0;
+        }
+        return *this;
+    }
+
+    /** Construct an owning, validated validator bitset. */
+    static std::optional<ValidatedValidatorBitset>
+    make(Slice bitset, std::size_t memberCount);
+
+    std::size_t
+    selected() const
+    {
+        return selected_;
+    }
+
+    bool
+    contains(std::size_t position) const
+    {
+        if (position >= memberCount_)
+            return false;
+
+        auto const byte = position / 8;
+        return (bitset_[byte] &
+                static_cast<std::uint8_t>(1u << (position % 8))) != 0;
+    }
+};
+
+constexpr std::size_t
+validatorBitsetBytes(std::size_t memberCount)
+{
+    return memberCount / 8 + (memberCount % 8 != 0);
+}
+
+/** Validate an LSB-first bitset over a fixed canonical validator universe.
+
+    A valid bitset has exactly enough bytes for the universe and leaves every
+    unused high bit in the final byte clear. The returned population can be
+    used by a caller's profile-specific admission and quorum rules.
+*/
+inline std::optional<ValidatedValidatorBitset>
+validateValidatorBitset(Slice bitset, std::size_t memberCount)
+{
+    return ValidatedValidatorBitset::make(bitset, memberCount);
+}
+
+inline std::optional<ValidatedValidatorBitset>
+ValidatedValidatorBitset::make(Slice bitset, std::size_t memberCount)
+{
+    if (bitset.size() != validatorBitsetBytes(memberCount))
+        return std::nullopt;
+
+    auto const remainder = memberCount % 8;
+    if (remainder != 0)
+    {
+        auto const allowed = static_cast<std::uint8_t>((1u << remainder) - 1u);
+        if ((bitset[bitset.size() - 1] & static_cast<std::uint8_t>(~allowed)) !=
+            0)
+            return std::nullopt;
+    }
+
+    std::size_t selected = 0;
+    for (auto const byte : bitset)
+        selected += std::popcount(byte);
+
+    return ValidatedValidatorBitset{bitset, memberCount, selected};
+}
+
+template <class Predicate>
+Blob
+makeValidatorBitset(std::size_t memberCount, Predicate&& selected)
+{
+    Blob bitset(validatorBitsetBytes(memberCount), 0);
+    for (std::size_t i = 0; i < memberCount; ++i)
+    {
+        if (selected(i))
+            bitset[i / 8] |= static_cast<std::uint8_t>(1u << (i % 8));
+    }
+    return bitset;
+}
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/detail/features.macro

@@ -23,6 +23,9 @@
 #if !defined(XRPL_FIX)
 #error "undefined macro: XRPL_FIX"
 #endif
+#if !defined(XRPL_RETIRE)
+#error "undefined macro: XRPL_RETIRE"
+#endif
 
 // clang-format off
 
@@ -31,7 +34,11 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
-XRPL_FEATURE(JSHooks,                    Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(OnChainManifests,           Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (HookMap,                    Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (GuardDepth32,               Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(NamedHooks,                 Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(IOURewardClaim,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (IOULockedBalanceInvariant,  Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ImportIssuer,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookAPISerializedType240,   Supported::yes, VoteBehavior::DefaultNo)
@@ -55,18 +62,20 @@ XRPL_FIX    (FillOrKill,                 Supported::yes, VoteBehavior::DefaultYe
 XRPL_FEATURE(DID,                        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DisallowIncomingV1,         Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(XChainBridge,               Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(AMM,                        Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(AMM,                        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (ReducedOffersV1,            Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(HookOnV2,                   Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes);
+XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(HookOnV2,                   Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(Export,                     Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(ConsensusEntropy,           Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(Clawback,                   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (RewardClaimFlags,           Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookCanEmit,                Supported::yes, VoteBehavior::DefaultNo)
@@ -82,8 +91,6 @@ XRPL_FIX    (240819,                     Supported::yes, VoteBehavior::DefaultYe
 XRPL_FIX    (NSDelete,                   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(ZeroB2M,                    Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Remit,                      Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (XahauV2,                    Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (XahauV1,                    Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(HooksUpdate1,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(XahauGenesis,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(Import,                     Supported::yes, VoteBehavior::DefaultYes)
@@ -150,4 +157,26 @@ XRPL_FIX    (NFTokenDirV1,          Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(NonFungibleTokensV1,   Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(CryptoConditionsSuite, Supported::yes, VoteBehavior::Obsolete)
 
+// The following amendments have been active for at least two years. Their
+// pre-amendment code has been removed and the identifiers are deprecated.
+// All known amendments and amendments that may appear in a validated
+// ledger must be registered either here or above with the "active" amendments
+XRPL_RETIRE(fixXahauV2)
+XRPL_RETIRE(fixXahauV1)
+XRPL_RETIRE(MultiSign)
+XRPL_RETIRE(TrustSetAuth)
+XRPL_RETIRE(FeeEscalation)
+XRPL_RETIRE(PayChan)
+XRPL_RETIRE(CryptoConditions)
+XRPL_RETIRE(TickSize)
+XRPL_RETIRE(fix1368)
+XRPL_RETIRE(Escrow)
+XRPL_RETIRE(fix1373)
+XRPL_RETIRE(EnforceInvariants)
+XRPL_RETIRE(SortedDirectories)
+XRPL_RETIRE(fix1201)
+XRPL_RETIRE(fix1512)
+XRPL_RETIRE(fix1523)
+XRPL_RETIRE(fix1528)
+
 // clang-format on

include/xrpl/protocol/detail/ledger_entries.macro

@@ -93,7 +93,7 @@ LEDGER_ENTRY(ltCHECK, 0x0043, Check, check, ({
 */
 LEDGER_ENTRY(ltHOOK_DEFINITION, 'D', HookDefinition, hook_definition, ({
     {sfHookHash,             soeREQUIRED},
-    {sfHookOn,               soeREQUIRED},
+    {sfHookOn,               soeOPTIONAL},
     {sfHookOnIncoming,       soeOPTIONAL},
     {sfHookOnOutgoing,       soeOPTIONAL},
     {sfHookCanEmit,          soeOPTIONAL},
@@ -223,6 +223,23 @@ LEDGER_ENTRY(ltURI_TOKEN, 0x0055, URIToken, uri_token, ({
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
 
+/** The ledger object which stores consensus-derived entropy.
+
+    \note This is a singleton: only one such object exists in the ledger.
+
+    \sa keylet::consensusEntropy
+ */
+LEDGER_ENTRY_DUPLICATE(ltCONSENSUS_ENTROPY, 0x0058, ConsensusEntropy, consensus_entropy, ({
+    {sfDigest,               soeREQUIRED},
+    {sfEntropyCount,         soeREQUIRED},
+    {sfEntropyDenominator,   soeREQUIRED},
+    {sfEntropyContributors,  soeREQUIRED},
+    {sfEntropyTier,          soeREQUIRED},
+    {sfLedgerSequence,       soeREQUIRED},
+    {sfPreviousTxnID,        soeREQUIRED},
+    {sfPreviousTxnLgrSeq,    soeREQUIRED},
+}))
+
 /** A ledger object which describes an account.
 
     \sa keylet::account
@@ -257,11 +274,15 @@ LEDGER_ENTRY(ltACCOUNT_ROOT, 0x0061, AccountRoot, account, ({
     {sfImportSequence,       soeOPTIONAL},
     {sfGovernanceFlags,      soeOPTIONAL},
     {sfGovernanceMarks,      soeOPTIONAL},
+    //@@start account-index-optional-accountroot-field
     {sfAccountIndex,         soeOPTIONAL},
+    //@@end account-index-optional-accountroot-field
     {sfTouchCount,           soeOPTIONAL},
     {sfHookStateScale,       soeOPTIONAL},
     {sfCron,                 soeOPTIONAL},
     {sfAMMID,                soeOPTIONAL},
+    {sfExportCount,          soeOPTIONAL},
+    {sfManifestID,           soeOPTIONAL},
 }))
 
 /** A ledger object which contains a list of object identifiers.
@@ -277,6 +298,7 @@ LEDGER_ENTRY(ltDIR_NODE, 0x0064, DirectoryNode, directory, ({
     {sfTakerGetsIssuer,      soeOPTIONAL},  // order book directories
     {sfExchangeRate,         soeOPTIONAL},  // order book directories
     {sfReferenceCount,       soeOPTIONAL},  // for hook state directories
+    {sfExportCount,          soeOPTIONAL},  // live latches on Export root
     {sfIndexes,              soeREQUIRED},
     {sfRootIndex,            soeREQUIRED},
     {sfIndexNext,            soeOPTIONAL},
@@ -396,6 +418,8 @@ LEDGER_ENTRY(ltRIPPLE_STATE, 0x0072, RippleState, state, ({
     {sfHighQualityOut,       soeOPTIONAL},
     {sfLockedBalance,        soeOPTIONAL},
     {sfLockCount,            soeOPTIONAL},
+    {sfHighReward,           soeOPTIONAL},
+    {sfLowReward,            soeOPTIONAL},
 }))
 
 /** The ledger object which lists the network's fee settings.
@@ -415,7 +439,9 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
     {sfReserveBaseDrops,       soeOPTIONAL},
     {sfReserveIncrementDrops,  soeOPTIONAL},
     {sfXahauActivationLgrSeq,  soeOPTIONAL},
+    //@@start account-count-optional-fees-field
     {sfAccountCount,           soeOPTIONAL},
+    //@@end account-count-optional-fees-field
     {sfNetworkID,              soeOPTIONAL},
     {sfPreviousTxnID,          soeOPTIONAL},
     {sfPreviousTxnLgrSeq,      soeOPTIONAL},
@@ -590,6 +616,58 @@ LEDGER_ENTRY(ltDID, 0x008D, DID, did, ({
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
 
+//@@start export-latch-ledger-entry
+/** A live lifecycle latch for an Export intent.
+
+    Created when an Export intent is admitted. It records witness and
+    proof-of-execution arrival in either order and is erased once both facts
+    exist. Account-owned (pays reserve).
+    sfDigest stores the canonical target signing-intent hash.
+
+    \sa keylet::exportLatch
+ */
+LEDGER_ENTRY(ltEXPORT_LATCH, 0x5374, ExportLatch, export_latch, ({
+    {sfAccount,              soeREQUIRED},
+    {sfExportCallbackFee, soeOPTIONAL},
+    {sfTicketSequence,       soeREQUIRED},
+    {sfTransactionHash,      soeOPTIONAL},
+    {sfDigest,               soeREQUIRED},
+    {sfLedgerSequence,       soeREQUIRED},
+    {sfExportCommitteeHash,  soeREQUIRED},
+    {sfExportSignatureHash,  soeOPTIONAL},
+    {sfLastLedgerSequence,   soeOPTIONAL},
+    {sfOwnerNode,            soeREQUIRED},
+    {sfExportNode,           soeOPTIONAL},
+}))
+//@@end export-latch-ledger-entry
+
+/** An immutable, account-owned Export validator committee. */
+LEDGER_ENTRY(ltEXPORT_COMMITTEE, 0x4563, ExportCommittee, export_committee, ({
+    {sfAccount,              soeREQUIRED},
+    {sfExportCommitteeHash,  soeREQUIRED},
+    {sfExportCommittee,      soeREQUIRED},
+    {sfOwnerNode,            soeREQUIRED},
+}))
+
+LEDGER_ENTRY(ltMANIFEST, 0x004D, Manifest, manifest_entry, ({
+    {sfAccount,             soeREQUIRED},
+    {sfPublicKey,           soeREQUIRED},
+    {sfSigningPubKey,       soeOPTIONAL}, /* may be absent if the master is revoked */
+    {sfSequence,            soeREQUIRED},
+    /* sfVersion defaults to 0 and is omitted from the signed payload when
+       absent. Storing it unconditionally would change the bytes and break
+       signature verification when the manifest is reconstructed. */
+    {sfVersion,             soeOPTIONAL},
+    {sfDomain,              soeOPTIONAL},
+    /* The signatures are mirrored so the object is a lossless copy of the
+       manifest and can be independently verified, and re-served to peers,
+       by any node reading it (see ManifestCache::applyLedger). */
+    {sfMasterSignature,     soeREQUIRED},
+    {sfSignature,           soeOPTIONAL}, /* absent if the master is revoked */
+    {sfManifestID,          soeOPTIONAL}, /* pointer to the identical other copy on the other key */
+    {sfPreviousTxnID,       soeREQUIRED},
+    {sfPreviousTxnLgrSeq,   soeREQUIRED},
+}))
+
 #undef EXPAND
 #undef LEDGER_ENTRY_DUPLICATE
-

include/xrpl/protocol/detail/sfields.macro

@@ -42,6 +42,8 @@ TYPED_SFIELD(sfTickSize,                 UINT8,     16)
 TYPED_SFIELD(sfUNLModifyDisabling,       UINT8,     17)
 TYPED_SFIELD(sfHookResult,               UINT8,     18)
 TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
+TYPED_SFIELD(sfSidecarType,              UINT8,     20)
+TYPED_SFIELD(sfEntropyTier,              UINT8,     21)
 
 // 16-bit integers (common)
 TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::sMD_Never)
@@ -59,6 +61,10 @@ TYPED_SFIELD(sfHookExecutionIndex,       UINT16,    19)
 TYPED_SFIELD(sfHookApiVersion,           UINT16,    20)
 TYPED_SFIELD(sfHookStateScale,           UINT16,    21)
 TYPED_SFIELD(sfLedgerFixType,            UINT16,    22)
+TYPED_SFIELD(sfHookExportCount,          UINT16,    98)
+TYPED_SFIELD(sfEntropyCount,             UINT16,    99)
+TYPED_SFIELD(sfEntropyDenominator,       UINT16,   100)
+TYPED_SFIELD(sfExportCount,              UINT16,   101)
 
 // 32-bit integers (common)
 TYPED_SFIELD(sfNetworkID,                UINT32,     1)
@@ -153,6 +159,7 @@ TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::sMD_BaseTen|SFie
 TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::sMD_BaseTen|SField::sMD_Default)
 TYPED_SFIELD(sfIssuerNode,               UINT64,    27)
 TYPED_SFIELD(sfSubjectNode,              UINT64,    28)
+TYPED_SFIELD(sfExportNode,               UINT64,    29)
 TYPED_SFIELD(sfTouchCount,               UINT64,    97)
 TYPED_SFIELD(sfAccountIndex,             UINT64,    98)
 TYPED_SFIELD(sfAccountCount,             UINT64,    99)
@@ -210,6 +217,9 @@ TYPED_SFIELD(sfOfferID,                  UINT256,   34)
 TYPED_SFIELD(sfEscrowID,                 UINT256,   35)
 TYPED_SFIELD(sfURITokenID,               UINT256,   36)
 TYPED_SFIELD(sfDomainID,                 UINT256,   37)
+TYPED_SFIELD(sfExportSignatureHash,      UINT256,   38)
+TYPED_SFIELD(sfExportCommitteeHash,      UINT256,   39)
+TYPED_SFIELD(sfManifestID,               UINT256,   91)
 TYPED_SFIELD(sfHookOnOutgoing,           UINT256,   93)
 TYPED_SFIELD(sfHookOnIncoming,           UINT256,   94)
 TYPED_SFIELD(sfCron,                     UINT256,   95)
@@ -257,6 +267,8 @@ TYPED_SFIELD(sfPrice,                    AMOUNT,    28)
 TYPED_SFIELD(sfSignatureReward,          AMOUNT,    29)
 TYPED_SFIELD(sfMinAccountCreateAmount,   AMOUNT,    30)
 TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
+TYPED_SFIELD(sfExportCallbackFee,        AMOUNT,    32)
+TYPED_SFIELD(sfTrustLineRewardAccumulator,AMOUNT,   99)
 
 // variable length (common)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
@@ -292,6 +304,10 @@ TYPED_SFIELD(sfAssetClass,               VL,        29)
 TYPED_SFIELD(sfProvider,                 VL,        30)
 TYPED_SFIELD(sfMPTokenMetadata,          VL,        31)
 TYPED_SFIELD(sfCredentialType,           VL,        32)
+TYPED_SFIELD(sfEntropyContributors,      VL,        33)
+TYPED_SFIELD(sfExportCommittee,          VL,        34)
+TYPED_SFIELD(sfExportContributors,       VL,        35)
+TYPED_SFIELD(sfHookName,                 VL,        97)
 TYPED_SFIELD(sfRemarkValue,              VL,        98)
 TYPED_SFIELD(sfRemarkName,               VL,        99)
 
@@ -340,6 +356,7 @@ TYPED_SFIELD(sfLockingChainIssue,        ISSUE,      1)
 TYPED_SFIELD(sfIssuingChainIssue,        ISSUE,      2)
 TYPED_SFIELD(sfAsset,                    ISSUE,      3)
 TYPED_SFIELD(sfAsset2,                   ISSUE,      4)
+TYPED_SFIELD(sfClaimCurrency,            ISSUE,      5)
 
 // bridge
 TYPED_SFIELD(sfXChainBridge,             XCHAIN_BRIDGE, 1)
@@ -362,7 +379,7 @@ UNTYPED_SFIELD(sfHook,                   OBJECT,    14)
 
 // inner object (uncommon)
 UNTYPED_SFIELD(sfSigner,                 OBJECT,    16)
-//                                                  17 unused
+UNTYPED_SFIELD(sfExportSigner,           OBJECT,    17)
 UNTYPED_SFIELD(sfMajority,               OBJECT,    18)
 UNTYPED_SFIELD(sfDisabledValidator,      OBJECT,    19)
 UNTYPED_SFIELD(sfEmittedTxn,             OBJECT,    20)
@@ -379,6 +396,8 @@ UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
+UNTYPED_SFIELD(sfExportedTxn,            OBJECT,    89)
+UNTYPED_SFIELD(sfManifest,               OBJECT,    90)
 UNTYPED_SFIELD(sfAmountEntry,            OBJECT,    91)
 UNTYPED_SFIELD(sfMintURIToken,           OBJECT,    92)
 UNTYPED_SFIELD(sfHookEmission,           OBJECT,    93)
@@ -386,6 +405,8 @@ UNTYPED_SFIELD(sfImportVLKey,            OBJECT,    94)
 UNTYPED_SFIELD(sfActiveValidator,        OBJECT,    95)
 UNTYPED_SFIELD(sfGenesisMint,            OBJECT,    96)
 UNTYPED_SFIELD(sfRemark,                 OBJECT,    97)
+UNTYPED_SFIELD(sfHighReward,             OBJECT,    98)
+UNTYPED_SFIELD(sfLowReward,              OBJECT,    99)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array
@@ -410,7 +431,7 @@ UNTYPED_SFIELD(sfHookParameters,         ARRAY,     19)
 UNTYPED_SFIELD(sfHookGrants,             ARRAY,     20)
 UNTYPED_SFIELD(sfXChainClaimAttestations, ARRAY,    21)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestations, ARRAY, 22)
-//                                                  23 unused
+UNTYPED_SFIELD(sfExportSigners,          ARRAY,     23)
 UNTYPED_SFIELD(sfPriceDataSeries,        ARRAY,     24)
 UNTYPED_SFIELD(sfAuthAccounts,           ARRAY,     25)
 UNTYPED_SFIELD(sfAuthorizeCredentials,   ARRAY,     26)

include/xrpl/protocol/detail/transactions.macro

@@ -500,6 +500,23 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 72, PermissionedDomainDelete, ({
     {sfDomainID, soeREQUIRED},
 }))
 
+//@@start export-transaction-types
+/* User-submittable Export. Its mutually exclusive forms create an intent,
+   control an existing latch, or manage an immutable committee object. */
+TRANSACTION(ttEXPORT, 90, Export, ({
+    {sfExportedTxn, soeOPTIONAL},
+    {sfExportCallbackFee, soeOPTIONAL},
+    {sfTransactionHash, soeOPTIONAL},
+    {sfExportCommitteeHash, soeOPTIONAL},
+    {sfExportCommittee, soeOPTIONAL},
+}))
+//@@end export-transaction-types
+/* sfAccount is supplied by TxFormats::commonFields; listing it here as well
+   makes the SOTemplate reject the format at construction. */
+TRANSACTION(ttMANIFEST_SET, 91, SetManifest, ({
+    {sfManifest, soeREQUIRED},
+}))
+
 /* A pseudo-txn alarm signal for invoking a hook, emitted by validators after alarm set conditions are met */
 TRANSACTION(ttCRON, 92, Cron, ({
     {sfOwner, soeREQUIRED},
@@ -550,6 +567,7 @@ TRANSACTION(ttIMPORT, 97, Import, ({
   * from a specified hook */
 TRANSACTION(ttCLAIM_REWARD, 98, ClaimReward, ({
     {sfIssuer, soeOPTIONAL},
+    {sfClaimCurrency, soeOPTIONAL},
 }))
 
 /** This transaction invokes a hook, providing arbitrary data. Essentially as a 0 drop payment. **/
@@ -605,3 +623,20 @@ TRANSACTION(ttUNL_REPORT, 104, UNLReport, ({
     {sfActiveValidator, soeOPTIONAL},
     {sfImportVLKey, soeOPTIONAL},
 }))
+
+TRANSACTION(ttCONSENSUS_ENTROPY, 105, ConsensusEntropy, ({
+    {sfLedgerSequence, soeREQUIRED},
+    {sfDigest, soeREQUIRED},
+    {sfEntropyCount, soeREQUIRED},
+    {sfEntropyDenominator, soeREQUIRED},
+    {sfEntropyContributors, soeREQUIRED},
+    {sfEntropyTier, soeREQUIRED},
+}))
+
+TRANSACTION(ttEXPORT_SIGNATURES, 106, ExportSignatures, ({
+    {sfLedgerSequence, soeREQUIRED},
+    {sfTransactionHash, soeREQUIRED},
+    {sfExportedTxn, soeREQUIRED},
+    {sfExportContributors, soeREQUIRED},
+    {sfExportSigners, soeREQUIRED},
+}))

include/xrpl/protocol/jss.h

@@ -76,6 +76,7 @@ JSS(Holder);              // field.
 JSS(HookApiVersion);      // field
 JSS(HookCanEmit);         // field
 JSS(HookHash);            // field
+JSS(HookName);            // field
 JSS(HookNamespace);       // field
 JSS(HookOn);              // field
 JSS(HookOnIncoming);      // field
@@ -291,7 +292,9 @@ JSS(duration_us);             // out: NetworkOPs
 JSS(effective);               // out: ValidatorList
                               // in: UNL
 JSS(elapsed_seconds);
-JSS(enabled);                // out: AmendmentTable
+JSS(enabled);                // out: AmendmentTable (on-ledger);
+                             //      ServerDefinitions (this server)
+JSS(ledger_enabled);         // out: ServerDefinitions (on-ledger)
 JSS(engine_result);          // out: NetworkOPs, TransactionSign, Submit
 JSS(engine_result_code);     // out: NetworkOPs, TransactionSign, Submit
 JSS(engine_result_message);  // out: NetworkOPs, TransactionSign, Submit
@@ -349,6 +352,7 @@ JSS(hash_mismatches);       // out: catalogue
 JSS(have_header);           // out: InboundLedger
 JSS(have_state);            // out: InboundLedger
 JSS(have_transactions);     // out: InboundLedger
+JSS(hooks);                 // in/out: AccountInfo
 JSS(high);                  // out: BookChanges
 JSS(highest_sequence);      // out: AccountInfo
 JSS(highest_ticket);        // out: AccountInfo
@@ -530,6 +534,9 @@ JSS(open_ledger_fee);         // out: TxQ
 JSS(open_ledger_level);       // out: TxQ
 JSS(oracles);                 // in: get_aggregate_price
 JSS(oracle_document_id);      // in: get_aggregate_price
+JSS(origin_ledger_hash);      // out: NetworkOPs
+JSS(origin_ledger_seq);       // out: NetworkOPs
+JSS(origin_txid);             // out: NetworkOPs
 JSS(owner);                   // in: LedgerEntry, out: NetworkOPs
 JSS(owner_funds);             // in/out: Ledger, NetworkOPs, AcceptedLedgerTx
 JSS(page_index);
@@ -651,6 +658,7 @@ JSS(state_now);               // in: Subscribe
 JSS(status);                  // error
 JSS(stop);                    // in: LedgerCleaner
 JSS(stop_history_tx_only);    // in: Unsubscribe, stop history tx stream
+JSS(stream);                  // out: NetworkOPs
 JSS(streams);                 // in: Subscribe, Unsubscribe
 JSS(strict);                  // in: AccountCurrencies, AccountInfo
 JSS(sub_index);               // in: LedgerEntry
@@ -732,6 +740,7 @@ JSS(TRANSACTION_FLAGS);     // out: RPC server_definitions
 JSS(TRANSACTION_FLAGS_INDICES);  // out: RPC server_definitions
 JSS(type_hex);                   // out: STPathSet
 JSS(unl);                        // out: UnlList
+JSS(committee_position);          // out: NetworkOPs
 JSS(unlimited);                  // out: Connection.h
 JSS(uptime);                     // out: GetCounts
 JSS(uri);                        // out: ValidatorSites

release-builder.sh

@@ -11,11 +11,11 @@ echo "START BUILDING (HOST)"
 echo "Cleaning previously built binary"
 rm -f release-build/xahaud
 
-BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
+BUILD_CORES=$(echo "scale=0 ; $(nproc) / 1.337" | bc)
 
 if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   #Default
-  BUILD_CORES=${BUILD_CORES:-8} 
+  BUILD_CORES=${BUILD_CORES:-8}
 fi
 
 # Ensure still works outside of GH Actions by setting these to /dev/null
@@ -31,21 +31,19 @@ echo "-- GITHUB_SHA:        $GITHUB_SHA"
 echo "-- GITHUB_RUN_NUMBER: $GITHUB_RUN_NUMBER"
 echo "-- CONTAINER_NAME:    $CONTAINER_NAME"
 
-which docker 2> /dev/null 2> /dev/null
-if [ "$?" -eq "1" ]
-then
+which docker 2>/dev/null 2>/dev/null
+if [ "$?" -eq "1" ]; then
   echo 'Docker not found. Install it first.'
   exit 1
 fi
 
-stat .git 2> /dev/null 2> /dev/null
-if [ "$?" -eq "1" ]
-then
+stat .git 2>/dev/null 2>/dev/null
+if [ "$?" -eq "1" ]; then
   echo 'Run this inside the source directory. (.git dir not found).'
   exit 1
 fi
 
-STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME |wc -l)
+STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME | wc -l)
 
 CACHE_VOLUME_NAME="xahau-release-builder-cache"
 
@@ -57,13 +55,14 @@ if false; then
   docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
-  rm -rf release-build;
-  mkdir -p release-build;
+  rm -rf release-build
+  mkdir -p release-build
 
   docker volume create $CACHE_VOLUME_NAME
 
   # Create inline Dockerfile with environment setup for build-full.sh
-  DOCKERFILE_CONTENT=$(cat <<'DOCKERFILE_EOF'
+  DOCKERFILE_CONTENT=$(
+    cat <<'DOCKERFILE_EOF'
 FROM ghcr.io/phusion/holy-build-box:4.0.1-amd64
 
 ARG BUILD_CORES=8
@@ -218,7 +217,7 @@ RUN /hbb_exe/activate-exec bash -c "ccache -M 100G && \
     ln -s ../../bin/ccache /usr/lib64/ccache/c++"
 
 DOCKERFILE_EOF
-)
+  )
 
   # Build custom Docker image
   IMAGE_NAME="xahaud-builder:latest"
@@ -228,14 +227,14 @@ DOCKERFILE_EOF
   if [[ "$GITHUB_REPOSITORY" == "" ]]; then
     # Non GH, local building
     echo "Non-GH runner, local building, temp container"
-    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
   else
     # GH Action, runner
     echo "GH Action, runner, clean & re-create create persistent container"
     docker rm -f $CONTAINER_NAME
-    echo "echo 'Stopping container: $CONTAINER_NAME'" >> "$JOB_CLEANUP_SCRIPT"
-    echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >> "$JOB_CLEANUP_SCRIPT"
-    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
+    echo "echo 'Stopping container: $CONTAINER_NAME'" >>"$JOB_CLEANUP_SCRIPT"
+    echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >>"$JOB_CLEANUP_SCRIPT"
+    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
     docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
     docker stop $CONTAINER_NAME
   fi

src/libxrpl/basics/Log.cpp

@@ -31,6 +31,7 @@
 #include <cassert>
 #include <cstring>
 #include <ctime>
+#include <exception>
 #include <fstream>
 #include <functional>
 #include <iostream>
@@ -351,9 +352,18 @@ Logs::format(
 
     if (useLocalTime)
     {
-        auto now = std::chrono::system_clock::now();
-        auto local = date::make_zoned(date::current_zone(), now);
-        output = date::format(fmt, local);
+        try
+        {
+            auto now = std::chrono::system_clock::now();
+            auto local = date::make_zoned(date::current_zone(), now);
+            output = date::format(fmt, local);
+        }
+        catch (std::exception const&)
+        {
+            // Enhanced logging should not make startup fatal if tzdb lookup is
+            // unavailable or misconfigured. Fall back to UTC formatting.
+            output = date::format(fmt, std::chrono::system_clock::now());
+        }
     }
     else
     {

src/libxrpl/protocol/AMMCore.cpp

@@ -66,7 +66,7 @@ invalidAMMAsset(
     Issue const& issue,
     std::optional<std::pair<Issue, Issue>> const& pair)
 {
-    if (badCurrency() == issue.currency)
+    if (isBadCurrency(issue.currency))
         return temBAD_CURRENCY;
     if (isXRP(issue) && issue.account.isNonZero())
         return temBAD_ISSUER;

src/libxrpl/protocol/BuildInfo.cpp

@@ -56,9 +56,9 @@ getVersionString()
         (versionString == std::string("0.") + std::string("0.0") ||
          versionString == std::string("0.0.0+DEBUG")))
     {
-        std::string y = std::string(__DATE__ + 7);
+        std::string y = std::string(&__DATE__[7]);
         std::string d = std::string(
-            __DATE__ + 4 + (__DATE__[4] == ' ' ? 1 : 0),
+            &__DATE__[4 + (__DATE__[4] == ' ' ? 1 : 0)],
             __DATE__[4] == ' ' ? 1 : 2);
         std::string m;
         switch (__DATE__[0])

src/libxrpl/protocol/ExportOriginMemo.cpp

@@ -0,0 +1,211 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+    IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <xrpl/protocol/ExportOriginMemo.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/Serializer.h>
+
+#include <algorithm>
+#include <exception>
+#include <iterator>
+#include <string>
+
+namespace ripple::ExportOriginMemo {
+namespace {
+
+Blob const&
+memoTypeBytes()
+{
+    static Blob const value(memoType.begin(), memoType.end());
+    return value;
+}
+
+bool
+isReserved(STObject const& memo)
+{
+    return memo.getFName() == sfMemo && memo.isFieldPresent(sfMemoType) &&
+        memo.getFieldVL(sfMemoType) == memoTypeBytes();
+}
+
+STObject
+cloneObject(STTx const& tx)
+{
+    Serializer serializer;
+    tx.add(serializer);
+    SerialIter sit{serializer.slice()};
+    STObject result{sfGeneric};
+    result.set(sit);
+    return result;
+}
+
+Blob
+serialize(Origin const& origin, std::optional<Anchor> const& anchor)
+{
+    //@@start export-origin-memo-wire-format
+    Serializer serializer;
+    serializer.add8(version);
+    serializer.add8(allowedFlags);
+    serializer.add32(origin.sourceDomain);
+    serializer.add32(origin.targetDomain);
+    serializer.addBitString(origin.transactionHash);
+    if (anchor)
+    {
+        serializer.add32(anchor->ledgerSequence);
+        serializer.addBitString(anchor->ledgerHash);
+    }
+    return serializer.getData();
+    //@@end export-origin-memo-wire-format
+}
+
+Expected<STTx, Error>
+append(
+    STTx const& base,
+    Origin const& origin,
+    std::optional<Anchor> const& anchor)
+{
+    if (hasReservedMemo(base))
+        return Unexpected(Error::reservedMemoPresent);
+
+    //@@start export-origin-memo-canonical-append
+    auto object = cloneObject(base);
+    STArray memos = object.isFieldPresent(sfMemos)
+        ? object.getFieldArray(sfMemos)
+        : STArray{sfMemos};
+
+    STObject memo{sfMemo};
+    memo.setFieldVL(sfMemoType, memoTypeBytes());
+    memo.setFieldVL(sfMemoData, serialize(origin, anchor));
+    memos.emplace_back(std::move(memo));
+    object.setFieldArray(sfMemos, memos);
+
+    STTx result{std::move(object)};
+    std::string reason;
+    if (!passesLocalChecks(result, reason))
+        return Unexpected(Error::localChecks);
+    return result;
+    //@@end export-origin-memo-canonical-append
+}
+
+Expected<Stamp, Error>
+parseData(Blob const& data)
+{
+    if (data.size() != identityBytes && data.size() != releaseBytes)
+        return Unexpected(Error::malformedMemo);
+
+    try
+    {
+        SerialIter sit{makeSlice(data)};
+        if (sit.get8() != version)
+            return Unexpected(Error::unsupportedVersion);
+        if (sit.get8() != allowedFlags)
+            return Unexpected(Error::unsupportedFlags);
+
+        Stamp stamp{
+            .origin =
+                Origin{
+                    .sourceDomain = sit.get32(),
+                    .targetDomain = sit.get32(),
+                    .transactionHash = sit.get256()},
+            .anchor = std::nullopt};
+
+        if (data.size() == releaseBytes)
+            stamp.anchor = Anchor{sit.get32(), sit.get256()};
+        if (!sit.empty())
+            return Unexpected(Error::malformedMemo);
+        return stamp;
+    }
+    catch (std::exception const&)
+    {
+        return Unexpected(Error::malformedMemo);
+    }
+}
+
+}  // namespace
+
+bool
+hasReservedMemo(STTx const& tx)
+{
+    if (!tx.isFieldPresent(sfMemos))
+        return false;
+
+    auto const& memos = tx.getFieldArray(sfMemos);
+    return std::any_of(memos.begin(), memos.end(), isReserved);
+}
+
+Expected<STTx, Error>
+identityForm(STTx const& base, Origin const& origin)
+{
+    return append(base, origin, std::nullopt);
+}
+
+Expected<STTx, Error>
+releaseForm(STTx const& base, Origin const& origin, Anchor const& anchor)
+{
+    return append(base, origin, anchor);
+}
+
+Expected<Stamp, Error>
+parse(STTx const& tx)
+{
+    std::string reason;
+    if (!passesLocalChecks(tx, reason))
+        return Unexpected(Error::localChecks);
+    if (!tx.isFieldPresent(sfMemos))
+        return Unexpected(Error::reservedMemoMissing);
+
+    auto const& memos = tx.getFieldArray(sfMemos);
+    auto found = memos.end();
+    for (auto it = memos.begin(); it != memos.end(); ++it)
+    {
+        if (!isReserved(*it))
+            continue;
+        if (found != memos.end())
+            return Unexpected(Error::reservedMemoPosition);
+        found = it;
+    }
+
+    if (found == memos.end())
+        return Unexpected(Error::reservedMemoMissing);
+    if (found != std::prev(memos.end()))
+        return Unexpected(Error::reservedMemoPosition);
+    if (found->isFieldPresent(sfMemoFormat) ||
+        !found->isFieldPresent(sfMemoData))
+        return Unexpected(Error::malformedMemo);
+
+    return parseData(found->getFieldVL(sfMemoData));
+}
+
+Expected<STTx, Error>
+projectIdentity(STTx const& stamped)
+{
+    auto parsed = parse(stamped);
+    if (!parsed)
+        return Unexpected(parsed.error());
+
+    auto object = cloneObject(stamped);
+    auto memos = object.getFieldArray(sfMemos);
+    memos.erase(std::prev(memos.end()));
+    if (memos.empty())
+        object.delField(sfMemos);
+    else
+        object.setFieldArray(sfMemos, memos);
+
+    return identityForm(STTx{std::move(object)}, parsed.value().origin);
+}
+
+}  // namespace ripple::ExportOriginMemo

src/libxrpl/protocol/Feature.cpp

@@ -250,12 +250,9 @@ FeatureCollections::registerFeature(
     Feature const* i = getByName(name);
     if (!i)
     {
-        // If this check fails, and you just added a feature, increase the
-        // numFeatures value in Feature.h
         check(
             features.size() < detail::numFeatures,
-            "More features defined than allocated. Adjust numFeatures in "
-            "Feature.h.");
+            "More features defined than allocated.");
 
         auto const f = sha512Half(Slice(name.data(), name.size()));
 
@@ -424,45 +421,26 @@ featureToName(uint256 const& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) \
     uint256 const feature##name = registerFeature(#name, supported, vote);
 #define XRPL_FIX(name, supported, vote) \
     uint256 const fix##name = registerFeature("fix" #name, supported, vote);
+#define XRPL_RETIRE(name)                                                     \
+    [[deprecated("The referenced amendment has been retired"), maybe_unused]] \
+    uint256 const retired##name = retireFeature(#name);
 
 #include <xrpl/protocol/detail/features.macro>
 
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
 
-// clang-format off
-
-// The following amendments have been active for at least two years. Their
-// pre-amendment code has been removed and the identifiers are deprecated.
-// All known amendments and amendments that may appear in a validated
-// ledger must be registered either here or above with the "active" amendments
-[[deprecated("The referenced amendment has been retired"), maybe_unused]]
-uint256 const
-    retiredMultiSign         = retireFeature("MultiSign"),
-    retiredTrustSetAuth      = retireFeature("TrustSetAuth"),
-    retiredFeeEscalation     = retireFeature("FeeEscalation"),
-    retiredPayChan           = retireFeature("PayChan"),
-    retiredCryptoConditions  = retireFeature("CryptoConditions"),
-    retiredTickSize          = retireFeature("TickSize"),
-    retiredFix1368           = retireFeature("fix1368"),
-    retiredEscrow            = retireFeature("Escrow"),
-    retiredFix1373           = retireFeature("fix1373"),
-    retiredEnforceInvariants = retireFeature("EnforceInvariants"),
-    retiredSortedDirectories = retireFeature("SortedDirectories"),
-    retiredFix1201           = retireFeature("fix1201"),
-    retiredFix1512           = retireFeature("fix1512"),
-    retiredFix1523           = retireFeature("fix1523"),
-    retiredFix1528           = retireFeature("fix1528");
-
-// clang-format on
-
 // All of the features should now be registered, since variables in a cpp file
 // are initialized from top to bottom.
 //

src/libxrpl/protocol/Indexes.cpp

@@ -74,6 +74,9 @@ enum class LedgerNameSpace : std::uint16_t {
     HOOK_DEFINITION = 'D',
     EMITTED_TXN = 'E',
     EMITTED_DIR = 'F',
+    EXPORT_LATCH = 0x5374,        // St
+    EXPORT_COMMITTEE = 0x4563,    // Ec
+    EXPORT_PENDING_DIR = 0x4570,  // Ep
     NFTOKEN_OFFER = 'q',
     NFTOKEN_BUY_OFFERS = 'h',
     NFTOKEN_SELL_OFFERS = 'i',
@@ -81,6 +84,7 @@ enum class LedgerNameSpace : std::uint16_t {
     IMPORT_VLSEQ = 'I',
     UNL_REPORT = 'R',
     CRON = 'L',
+    CONSENSUS_ENTROPY = 'X',
     AMM = 'A',
     BRIDGE = LEDGER_NAMESPACE2(0x01, 'H'),
     XCHAIN_CLAIM_ID = 'Q',
@@ -89,6 +93,7 @@ enum class LedgerNameSpace : std::uint16_t {
     ORACLE = LEDGER_NAMESPACE2(0x01, 'R'),
     MPTOKEN_ISSUANCE = '~',
     MPTOKEN = 't',
+    MANIFEST = 'M',
     CREDENTIAL = LEDGER_NAMESPACE2(0x01, 'D'),
     PERMISSIONED_DOMAIN = 'm',
 
@@ -188,6 +193,34 @@ emittedTxn(uint256 const& id) noexcept
     return {ltEMITTED_TXN, indexHash(LedgerNameSpace::EMITTED_TXN, id)};
 }
 
+//@@start export-origin-keylet
+Keylet
+exportLatch(AccountID const& account, uint256 const& originTxnHash) noexcept
+{
+    return {
+        ltEXPORT_LATCH,
+        indexHash(LedgerNameSpace::EXPORT_LATCH, account, originTxnHash)};
+}
+//@@end export-origin-keylet
+
+Keylet
+exportCommittee(AccountID const& account, uint256 const& digest) noexcept
+{
+    return {
+        ltEXPORT_COMMITTEE,
+        indexHash(LedgerNameSpace::EXPORT_COMMITTEE, account, digest)};
+}
+
+//@@start export-pending-directory-keylet
+Keylet const&
+pendingExports() noexcept
+{
+    static Keylet const ret{
+        ltDIR_NODE, indexHash(LedgerNameSpace::EXPORT_PENDING_DIR)};
+    return ret;
+}
+//@@end export-pending-directory-keylet
+
 Keylet
 hook(AccountID const& id) noexcept
 {
@@ -546,6 +579,14 @@ cron(uint32_t timestamp, std::optional<AccountID> const& id)
     return {ltCRON, uint256::fromVoid(h)};
 }
 
+Keylet const&
+consensusEntropy() noexcept
+{
+    static Keylet const ret{
+        ltCONSENSUS_ENTROPY, indexHash(LedgerNameSpace::CONSENSUS_ENTROPY)};
+    return ret;
+}
+
 Keylet
 amm(Asset const& issue1, Asset const& issue2) noexcept
 {
@@ -670,6 +711,12 @@ permissionedDomain(uint256 const& domainID) noexcept
     return {ltPERMISSIONED_DOMAIN, domainID};
 }
 
+Keylet
+manifest(PublicKey const& pk) noexcept
+{
+    return {ltMANIFEST, indexHash(LedgerNameSpace::MANIFEST, pk.slice())};
+}
+
 }  // namespace keylet
 
 }  // namespace ripple

src/libxrpl/protocol/InnerObjectFormats.cpp

@@ -53,6 +53,13 @@ InnerObjectFormats::InnerObjectFormats()
             {sfTxnSignature, soeREQUIRED},
         });
 
+    add(sfExportSigner.jsonName,
+        sfExportSigner.getCode(),
+        {
+            {sfSigningPubKey, soeREQUIRED},
+            {sfTxnSignature, soeREQUIRED},
+        });
+
     add(sfMajority.jsonName,
         sfMajority.getCode(),
         {
@@ -78,6 +85,7 @@ InnerObjectFormats::InnerObjectFormats()
          {sfHookExecutionIndex, soeREQUIRED},
          {sfHookStateChangeCount, soeREQUIRED},
          {sfHookEmitCount, soeREQUIRED},
+         {sfHookExportCount, soeOPTIONAL},
          {sfFlags, soeOPTIONAL}});
 
     add(sfHookEmission.jsonName,
@@ -99,7 +107,7 @@ InnerObjectFormats::InnerObjectFormats()
          {sfHookOnOutgoing, soeOPTIONAL},
          {sfHookCanEmit, soeOPTIONAL},
          {sfHookApiVersion, soeOPTIONAL},
-         {sfFee, soeOPTIONAL},
+         {sfHookName, soeOPTIONAL},
          {sfFlags, soeOPTIONAL}});
 
     add(sfHookGrant.jsonName,
@@ -254,6 +262,24 @@ InnerObjectFormats::InnerObjectFormats()
             {sfIssuer, soeREQUIRED},
             {sfCredentialType, soeREQUIRED},
         });
+
+    add(sfHighReward.jsonName,
+        sfHighReward.getCode(),
+        {
+            {sfRewardLgrFirst, soeREQUIRED},
+            {sfRewardLgrLast, soeREQUIRED},
+            {sfRewardTime, soeREQUIRED},
+            {sfTrustLineRewardAccumulator, soeREQUIRED},
+        });
+
+    add(sfLowReward.jsonName,
+        sfLowReward.getCode(),
+        {
+            {sfRewardLgrFirst, soeREQUIRED},
+            {sfRewardLgrLast, soeREQUIRED},
+            {sfRewardTime, soeREQUIRED},
+            {sfTrustLineRewardAccumulator, soeREQUIRED},
+        });
 }
 
 InnerObjectFormats const&

src/libxrpl/protocol/Issue.cpp

@@ -111,7 +111,7 @@ issueFromJson(Json::Value const& v)
     }
 
     auto const currency = to_currency(curStr.asString());
-    if (currency == badCurrency() || currency == noCurrency())
+    if (isBadCurrency(currency) || currency == noCurrency())
     {
         Throw<Json::error>("issueFromJson currency must be a valid currency");
     }

src/libxrpl/protocol/STCurrency.cpp

@@ -103,7 +103,7 @@ currencyFromJson(SField const& name, Json::Value const& v)
     }
 
     auto const currency = to_currency(v.asString());
-    if (currency == badCurrency() || currency == noCurrency())
+    if (isBadCurrency(currency) || currency == noCurrency())
     {
         Throw<std::runtime_error>(
             "currencyFromJson currency must be a valid currency");

src/libxrpl/protocol/STTx.cpp

@@ -684,7 +684,8 @@ isPseudoTx(STObject const& tx)
 
     auto tt = safe_cast<TxType>(*t);
     return tt == ttAMENDMENT || tt == ttFEE || tt == ttUNL_MODIFY ||
-        tt == ttEMIT_FAILURE || tt == ttUNL_REPORT || tt == ttCRON;
+        tt == ttEMIT_FAILURE || tt == ttUNL_REPORT || tt == ttCRON ||
+        tt == ttCONSENSUS_ENTROPY || tt == ttEXPORT_SIGNATURES;
 }
 
 }  // namespace ripple

src/libxrpl/protocol/TER.cpp

@@ -124,7 +124,7 @@ transResults()
         MAKE_ERROR(tecARRAY_TOO_LARGE,               "Array is too large."),
         MAKE_ERROR(tecLOCKED,                        "Fund is locked."),
         MAKE_ERROR(tecBAD_CREDENTIALS,               "Bad credentials."),
-        MAKE_ERROR(tecINVALID_HOOK_API_VERSION,      "Invalid field for current hook API version."),
+        MAKE_ERROR(tecEXPORT_COMMITTEE_UNAVAILABLE, "Export committee is unavailable in the parent validator view."),
 
         MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
         MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -152,6 +152,8 @@ transResults()
         MAKE_ERROR(tefNONDIR_EMIT,                 "An emitted txn was injected into the ledger without a corresponding directory entry."),
         MAKE_ERROR(tefIMPORT_BLACKHOLED,           "Cannot import keying because target account is blackholed."),
         MAKE_ERROR(tefINVALID_LEDGER_FIX_TYPE,     "The LedgerFixType field has an invalid value."),
+        MAKE_ERROR(tefPAST_MANIFEST_SEQ,           "The submitted manifest's sequence is not newer than the current."),
+        MAKE_ERROR(tefREVOKED_MANIFEST,            "The submitted manifest is for a revoked master key."),
 
         MAKE_ERROR(telLOCAL_ERROR,            "Local failure."),
         MAKE_ERROR(telBAD_DOMAIN,             "Domain too long."),
@@ -173,6 +175,7 @@ transResults()
         MAKE_ERROR(telIMPORT_VL_KEY_NOT_RECOGNISED, "Import vl key was not recognized."),
         MAKE_ERROR(telCAN_NOT_QUEUE_IMPORT,   "Import transaction was not able to be directly applied and cannot be queued."),
         MAKE_ERROR(telENV_RPC_FAILED,         "Unit test RPC failure."),
+        MAKE_ERROR(telEXPORT_LATCH_REQUIRED, "The imported Export callback has no matching Export latch."),
 
         MAKE_ERROR(temMALFORMED,                 "Malformed transaction."),
         MAKE_ERROR(temBAD_AMM_TOKENS,            "Malformed: Invalid LPTokens."),

src/libxrpl/protocol/TxFormats.cpp

@@ -48,6 +48,7 @@ TxFormats::TxFormats()
         {sfFirstLedgerSequence, soeOPTIONAL},
         {sfNetworkID, soeOPTIONAL},
         {sfHookParameters, soeOPTIONAL},
+        {sfHookName, soeOPTIONAL},
     };
 
 #pragma push_macro("UNWRAP")

src/quickjs/buffer-utils.c

@@ -1,820 +0,0 @@
-#include "defines.h"
-#include "char-utils.h"
-#include "buffer-utils.h"
-#include "utils.h"
-#ifdef _WIN32
-#include <windows.h>
-#elif defined(HAVE_TERMIOS_H)
-#include <termios.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-#endif
-#include "debug.h"
-
-/**
- * \addtogroup buffer-utils
- * @{
- */
-size_t
-ansi_length(const char* str, size_t len) {
-  size_t i, n = 0, p;
-  for(i = 0; i < len;) {
-    if(str[i] == 0x1b && (p = ansi_skip(&str[i], len - i)) > 0) {
-      i += p;
-      continue;
-    }
-    n++;
-    i++;
-  }
-  return n;
-}
-
-size_t
-ansi_skip(const char* str, size_t len) {
-  size_t pos = 0;
-  if(str[pos] == 0x1b) {
-    if(++pos < len && str[pos] == '[') {
-      while(++pos < len)
-        if(is_alphanumeric_char(str[pos]))
-          break;
-      if(++pos < len && str[pos] == '~')
-        ++pos;
-      return pos;
-    }
-  }
-  return 0;
-}
-
-size_t
-ansi_truncate(const char* str, size_t len, size_t limit) {
-  size_t i, n = 0, p;
-  for(i = 0; i < len;) {
-    if((p = ansi_skip(&str[i], len - i)) > 0) {
-      i += p;
-      continue;
-    }
-    n += is_escape_char(str[i]) ? 2 : 1;
-
-    i++;
-    if(n > limit)
-      break;
-  }
-  return i;
-}
-
-int64_t
-array_search(void* a, size_t m, size_t elsz, void* needle) {
-  char* ptr = a;
-  int64_t n, ret;
-  n = m / elsz;
-  for(ret = 0; ret < n; ret++) {
-    if(!memcmp(ptr, needle, elsz))
-      return ret;
-
-    ptr += elsz;
-  }
-  return -1;
-}
-
-char*
-str_escape(const char* s) {
-  DynBuf dbuf;
-  dbuf_init2(&dbuf, 0, 0);
-  dbuf_put_escaped(&dbuf, s, strlen(s));
-  dbuf_0(&dbuf);
-  return (char*)dbuf.buf;
-}
-
-char*
-byte_escape(const void* s, size_t n) {
-  DynBuf dbuf;
-  dbuf_init2(&dbuf, 0, 0);
-  dbuf_put_escaped(&dbuf, s, n);
-  dbuf_0(&dbuf);
-  return (char*)dbuf.buf;
-}
-
-size_t
-byte_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
-  size_t i, last;
-  const char* s = (const char*)haystack;
-  if(hlen < wlen)
-    return hlen;
-  last = hlen - wlen;
-  for(i = 0; i <= last; i++) {
-    if(byte_equal(s, wlen, what))
-      return i;
-    s++;
-  }
-  return hlen;
-}
-
-size_t
-byte_finds(const void* haystack, size_t hlen, const char* what) {
-  return byte_findb(haystack, hlen, what, strlen(what));
-}
-
-size_t
-byte_equal(const void* s, size_t n, const void* t) {
-  return memcmp(s, t, n) == 0;
-}
-
-void
-byte_copy(void* out, size_t len, const void* in) {
-  char* s = (char*)out;
-  const char* t = (const char*)in;
-  size_t i;
-  for(i = 0; i < len; ++i)
-    s[i] = t[i];
-}
-
-void
-byte_copyr(void* out, size_t len, const void* in) {
-  char* s = (char*)out + len;
-  const char* t = (const char*)in;
-  const char* u = t + len;
-
-  for(;;) {
-    if(t >= u)
-      break;
-    --u;
-    --s;
-    *s = *u;
-  }
-}
-
-size_t
-byte_rchrs(const char* in, size_t len, const char needles[], size_t nn) {
-  const char *s = in, *end = in + len, *found = 0;
-  size_t i;
-  for(; s < end; s++) {
-    for(i = 0; i < nn; ++i) {
-      if(*s == needles[i])
-        found = s;
-    }
-  }
-  return (size_t)((found ? found : s) - in);
-}
-
-char*
-dbuf_at_n(const DynBuf* db, size_t i, size_t* n, char sep) {
-  size_t p, l = 0;
-  for(p = 0; p < db->size; ++p) {
-    if(l == i) {
-      *n = byte_chr((const char*)&db->buf[p], db->size - p, sep);
-      return (char*)&db->buf[p];
-    }
-    if(db->buf[p] == sep)
-      ++l;
-  }
-  *n = 0;
-  return 0;
-}
-
-const char*
-dbuf_last_line(DynBuf* db, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(db->buf, db->size, '\n')) < db->size)
-    i++;
-  else
-    i = 0;
-
-  if(len)
-    *len = db->size - i;
-
-  return (const char*)&db->buf[i];
-}
-
-int
-dbuf_prepend(DynBuf* s, const uint8_t* data, size_t len) {
-  int ret;
-  if(!(ret = dbuf_reserve_start(s, len)))
-    memcpy(s->buf, data, len);
-
-  return 0;
-}
-
-void
-dbuf_put_colorstr(DynBuf* db, const char* str, const char* color, int with_color) {
-  if(with_color)
-    dbuf_putstr(db, color);
-
-  dbuf_putstr(db, str);
-  if(with_color)
-    dbuf_putstr(db, COLOR_NONE);
-}
-
-void
-dbuf_put_escaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(int)) {
-  size_t i = 0, j;
-  char c;
-
-  while(i < len) {
-    if((j = predicate_find(&str[i], len - i, pred))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-
-    if(i == len)
-      break;
-
-    dbuf_putc(db, '\\');
-
-    if(str[i] == 0x1b) {
-      dbuf_append(db, (const uint8_t*)"x1b", 3);
-    } else {
-      int r = pred(str[i]);
-
-      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(str[i])) ? c : str[i]);
-
-      if(r == 'u' || r == 'x')
-        dbuf_printf(db, r == 'u' ? "%04x" : "%02x", str[i]);
-    }
-
-    i++;
-  }
-}
-
-const uint8_t escape_url_tab[256] = {
-    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   '%',
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
-};
-
-const uint8_t escape_noquote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_singlequote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0x27, 0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_doublequote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x',  'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-
-    'x', 'x', 'x', 'x', 0,   0,   0x22, 0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_backquote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0,   0x76, 0x66, 0,   'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0x24, 0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,   0,    0x60, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u', 'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-void
-dbuf_put_escaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
-  size_t i = 0, clen;
-  int32_t c;
-  const uint8_t *pos, *end, *next;
-
-  for(pos = (const uint8_t*)str, end = pos + len; pos < end; pos = next) {
-    uint8_t r, ch;
-
-    if((c = unicode_from_utf8(pos, end - pos, &next)) < 0)
-      break;
-    clen = next - pos;
-    ch = c;
-    r = (clen >= 2 || c > 0xff) ? 'u' : table[c];
-
-    if(r == 'u' && clen > 1 && (c & 0xffffff00) == 0) {
-      r = 'x';
-      // ch = c >> 8;
-    }
-
-    if(r == '%') {
-      static const char hexdigits[] = "0123456789ABCDEF";
-
-      dbuf_putc(db, '%');
-      dbuf_putc(db, hexdigits[c >> 4]);
-      dbuf_putc(db, hexdigits[c & 0xf]);
-    } else if(c == 0x1b) {
-      dbuf_putstr(db, "\\x1b");
-    } else if(r == 'u') {
-      dbuf_printf(db, c > 0xffff ? "\\u{%X}" : "\\u%04x", c);
-    } else if(r == 'x') {
-      dbuf_printf(db, "\\x%02x", ch);
-    } else if(r) {
-      dbuf_putc(db, '\\');
-      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(ch)) ? c : ch);
-    } else {
-      dbuf_put(db, pos, next - pos);
-    }
-
-    i++;
-  }
-}
-
-void
-dbuf_put_unescaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(const char*, size_t*)) {
-  size_t i = 0, j;
-  // char c;
-
-  while(i < len) {
-    int r = 0;
-    if((j = byte_chr(&str[i], len - i, '\\'))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-    if(i == len)
-      break;
-    size_t n = 1;
-
-    if(pred) {
-      r = pred(&str[i + 1], &n);
-
-      if(!r && n == 1)
-        dbuf_putc(db, '\\');
-    }
-
-    if(r >= 0)
-      dbuf_putc(db, /*n > 1 ||*/ r ? /*(r > 1 && r < 256) ?*/ r : str[i]);
-    i += n;
-  }
-}
-
-static inline int
-hexdigit(char c) {
-  if(c >= '0' && c <= '9')
-    return c - '0';
-
-  if(c >= 'a' && c <= 'f')
-    c -= 32;
-
-  if(c >= 'A' && c <= 'F')
-    return c - 'A' + 10;
-
-  return -1;
-}
-
-void
-dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
-  size_t i = 0, j;
-  char escape_char = table == escape_url_tab ? '%' : '\\';
-
-  while(i < len) {
-    if((j = byte_chr(&str[i], len - i, escape_char))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-
-    if(i == len)
-      break;
-
-    if(escape_char == '%') {
-      int hi = hexdigit(str[i + 1]), lo = hexdigit(str[i + 2]);
-      uint8_t c = (hi << 4) | (lo & 0xf);
-      dbuf_putc(db, c);
-
-      i += 2;
-
-    } else {
-      ++i;
-
-      uint8_t c;
-
-      switch(str[i]) {
-        case 'b': c = '\b'; break;
-        case 't': c = '\t'; break;
-        case 'n': c = '\n'; break;
-        case 'v': c = '\v'; break;
-        case 'f': c = '\f'; break;
-        case 'r': c = '\r'; break;
-        default: c = str[i]; break;
-      }
-
-      uint8_t r = table[c];
-
-      if(!(r && r != 'x' && r != 'u')) {
-        dbuf_putc(db, '\\');
-        dbuf_putc(db, c);
-      } else {
-        dbuf_putc(db, str[i] == r ? c : r);
-      }
-    }
-
-    ++i;
-  }
-}
-
-void
-dbuf_put_escaped(DynBuf* db, const char* str, size_t len) {
-  return dbuf_put_escaped_table(db, str, len, escape_noquote_tab);
-}
-
-void
-dbuf_put_value(DynBuf* db, JSContext* ctx, JSValueConst value) {
-  const char* str;
-  size_t len;
-  str = JS_ToCStringLen(ctx, &len, value);
-  dbuf_append(db, str, len);
-  JS_FreeCString(ctx, str);
-}
-
-void
-dbuf_put_uint32(DynBuf* db, uint32_t num) {
-  char buf[FMT_ULONG];
-  dbuf_put(db, (const uint8_t*)buf, fmt_ulong(buf, num));
-}
-
-void
-dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom) {
-  const char* str;
-  str = JS_AtomToCString(ctx, atom);
-  dbuf_putstr(db, str);
-  JS_FreeCString(ctx, str);
-}
-
-int
-dbuf_reserve_start(DynBuf* s, size_t len) {
-  if(unlikely((s->size + len) > s->allocated_size)) {
-    if(dbuf_realloc(s, s->size + len))
-      return -1;
-  }
-  if(s->size > 0)
-    memcpy(s->buf + len, s->buf, s->size);
-
-  s->size += len;
-  return 0;
-}
-
-uint8_t*
-dbuf_reserve(DynBuf* s, size_t len) {
-  if(unlikely((s->size + len) > s->allocated_size))
-    if(dbuf_realloc(s, s->size + len))
-      return 0;
-
-  return &s->buf[s->size];
-}
-
-size_t
-dbuf_token_pop(DynBuf* db, char delim) {
-  size_t n, p, len;
-  len = db->size;
-  for(n = db->size; n > 0;) {
-    if((p = byte_rchr(db->buf, n, delim)) == n) {
-      db->size = 0;
-      break;
-    }
-    if(p > 0 && db->buf[p - 1] == '\\') {
-      n = p - 1;
-      continue;
-    }
-    db->size = p;
-    break;
-  }
-  return len - db->size;
-}
-
-size_t
-dbuf_token_push(DynBuf* db, const char* str, size_t len, char delim) {
-  size_t pos;
-  if(db->size)
-    dbuf_putc(db, delim);
-
-  pos = db->size;
-  dbuf_put_escaped_pred(db, str, len, is_dot_char);
-  return db->size - pos;
-}
-
-JSValue
-dbuf_tostring_free(DynBuf* s, JSContext* ctx) {
-  JSValue r;
-  r = JS_NewStringLen(ctx, s->buf ? (const char*)s->buf : "", s->buf ? s->size : 0);
-  dbuf_free(s);
-  return r;
-}
-
-ssize_t
-dbuf_load(DynBuf* s, const char* filename) {
-  FILE* fp;
-  size_t nbytes = 0;
-  if((fp = fopen(filename, "rb"))) {
-    char buf[4096];
-    size_t r;
-    while(!feof(fp)) {
-      if((r = fread(buf, 1, sizeof(buf), fp)) == 0) {
-        fclose(fp);
-        return -1;
-      }
-      dbuf_put(s, (uint8_t const*)buf, r);
-      nbytes += r;
-    }
-    fclose(fp);
-  }
-  return nbytes;
-}
-
-int
-dbuf_vprintf(DynBuf* s, const char* fmt, va_list ap) {
-
-  s->size += vsnprintf((char*)(s->buf + s->size), s->allocated_size - s->size, fmt, ap);
-
-  return 0;
-}
-
-InputBuffer
-js_input_buffer(JSContext* ctx, JSValueConst value) {
-  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, {0, INT64_MAX}};
-
-  if(js_is_typedarray(ctx, value)) {
-    ret.value = offset_typedarray(&ret.range, value, ctx);
-  } else if(js_is_arraybuffer(ctx, value) || js_is_sharedarraybuffer(ctx, value)) {
-    ret.value = JS_DupValue(ctx, value);
-  }
-
-  if(js_is_arraybuffer(ctx, ret.value) || js_is_sharedarraybuffer(ctx, ret.value)) {
-    block_arraybuffer(&ret.block, ret.value, ctx);
-  } else {
-    JS_ThrowTypeError(ctx, "Invalid type (%s) for input buffer", js_value_typestr(ctx, ret.value));
-    JS_FreeValue(ctx, ret.value);
-    ret.value = JS_EXCEPTION;
-  }
-
-  return ret;
-}
-
-#undef free
-
-InputBuffer
-js_input_chars(JSContext* ctx, JSValueConst value) {
-  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, OFFSET_INIT()};
-
-  if(JS_IsString(value)) {
-    ret.data = (uint8_t*)JS_ToCStringLen(ctx, &ret.size, value);
-    ret.value = JS_DupValue(ctx, value);
-    ret.free = &input_buffer_free_default;
-  } else {
-    ret = js_input_buffer(ctx, value);
-  }
-
-  return ret;
-}
-
-InputBuffer
-js_input_args(JSContext* ctx, int argc, JSValueConst argv[]) {
-  InputBuffer input = js_input_chars(ctx, argv[0]);
-
-  if(argc > 1)
-    js_offset_length(ctx, input.size, argc - 1, argv + 1, &input.range);
-
-  return input;
-}
-
-InputBuffer
-js_output_args(JSContext* ctx, int argc, JSValueConst argv[]) {
-  InputBuffer output = js_input_buffer(ctx, argv[0]);
-
-  if(argc > 1)
-    js_offset_length(ctx, output.size, argc - 1, argv + 1, &output.range);
-
-  return output;
-}
-
-BOOL
-input_buffer_valid(const InputBuffer* in) {
-  return !JS_IsException(in->value);
-}
-
-InputBuffer
-input_buffer_clone(const InputBuffer* in, JSContext* ctx) {
-  InputBuffer ret = js_input_buffer(ctx, in->value);
-
-  ret.pos = in->pos;
-  ret.size = in->size;
-  ret.free = in->free;
-
-  return ret;
-}
-
-void
-input_buffer_dump(const InputBuffer* in, DynBuf* db) {
-  dbuf_printf(db, "(InputBuffer){ .data = %p, .size = %lu, .pos = %lu, .free = %p }", in->data, (unsigned long)in->size, (unsigned long)in->pos, in->free);
-}
-
-void
-input_buffer_free(InputBuffer* in, JSContext* ctx) {
-  if(in->data) {
-    in->free(ctx, (const char*)in->data, in->value);
-    in->data = 0;
-    in->size = 0;
-    in->pos = 0;
-    in->value = JS_UNDEFINED;
-  }
-}
-
-const uint8_t*
-input_buffer_peek(InputBuffer* in, size_t* lenp) {
-  input_buffer_peekc(in, lenp);
-  return input_buffer_data(in) + in->pos;
-}
-
-const uint8_t*
-input_buffer_get(InputBuffer* in, size_t* lenp) {
-  const uint8_t* ret = input_buffer_peek(in, lenp);
-
-  in->pos += *lenp;
-
-  return ret;
-}
-
-const char*
-input_buffer_currentline(InputBuffer* in, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
-    i++;
-
-  if(len)
-    *len = in->pos - i;
-
-  return (const char*)&input_buffer_data(in)[i];
-}
-
-size_t
-input_buffer_column(InputBuffer* in, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
-    i++;
-
-  return in->pos - i;
-}
-
-int
-js_offset_length(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p) {
-  int ret = 0;
-  int64_t off = 0, len = size;
-
-  if(argc >= 1 && JS_IsNumber(argv[0])) {
-    if(!JS_ToInt64(ctx, &off, argv[0]))
-      ret = 1;
-
-    if(argc >= 2 && JS_IsNumber(argv[1]))
-      if(!JS_ToInt64(ctx, &len, argv[1]))
-        ret = 2;
-
-    if(size && off != size)
-      off = ((off % size) + size) % size;
-
-    if(len >= 0)
-      len = MIN_NUM(len, size - off);
-    else
-      len = size - off;
-
-    if(off_len_p) {
-      off_len_p->offset = off;
-      off_len_p->length = len;
-    }
-  }
-
-  return ret;
-}
-
-int
-js_index_range(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p) {
-  int ret = 0;
-  int64_t start = 0, end = size;
-
-  if(argc >= 1 && JS_IsNumber(argv[0])) {
-    if(!JS_ToInt64(ctx, &start, argv[0]))
-      ret = 1;
-
-    if(argc >= 2 && JS_IsNumber(argv[1]))
-      if(!JS_ToInt64(ctx, &end, argv[1]))
-        ret = 2;
-
-    if(size > 0) {
-      start = ((start % size) + size) % size;
-      end = ((end % size) + size) % size;
-    }
-
-    if(end > size)
-      end = size;
-
-    if(idx_rng_p) {
-      idx_rng_p->start = start;
-      idx_rng_p->end = end;
-    }
-  }
-
-  return ret;
-}
-
-int
-screen_size(int size[2]) {
-#ifdef _WIN32
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-
-  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
-  size[0] = csbi.srWindow.Right - csbi.srWindow.Left + 1;
-  size[1] = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
-  return 0;
-
-#elif defined(HAVE_TERMIOS_H)
-  {
-    struct winsize w = {.ws_col = -1, .ws_row = -1};
-
-    if(isatty(STDIN_FILENO))
-      ioctl(STDIN_FILENO, TIOCGWINSZ, &w);
-    else if(isatty(STDOUT_FILENO))
-      ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
-    else if(isatty(STDERR_FILENO))
-      ioctl(STDERR_FILENO, TIOCGWINSZ, &w);
-
-    size[0] = w.ws_col;
-    size[1] = w.ws_row;
-    return 0;
-  }
-#else
-  size[0] = 80;
-  size[1] = 25;
-  return 0;
-#endif
-  return -1;
-}
-
-#undef js_realloc_rt
-void
-js_dbuf_allocator(JSContext* ctx, DynBuf* s) {
-  dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc*)js_realloc_rt);
-}
-
-inline int
-input_buffer_peekc(InputBuffer* in, size_t* lenp) {
-  const uint8_t *pos, *end, *next;
-  int cp;
-  pos = input_buffer_data(in) + in->pos;
-  end = input_buffer_data(in) + input_buffer_length(in);
-  cp = unicode_from_utf8(pos, end - pos, &next);
-
-  *lenp = next - pos;
-
-  return cp;
-}
-
-inline int
-input_buffer_putc(InputBuffer* in, unsigned int c, JSContext* ctx) {
-  int len;
-
-  if(in->pos + UTF8_CHAR_LEN_MAX > in->size)
-    if(block_realloc(&in->block, in->pos + UTF8_CHAR_LEN_MAX, ctx))
-      return -1;
-
-  len = unicode_to_utf8(&in->data[in->pos], c);
-
-  in->pos += len;
-
-  return len;
-}
-
-size_t
-dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]) {
-  size_t i, n = 0;
-  for(i = 0; i < sizeof(bits) * 8; i++) {
-    if(bits & (1 << i)) {
-      size_t len = strlen(names[i]);
-      if(n) {
-        n++;
-        dbuf_putstr(db, "|");
-      }
-      dbuf_append(db, names[i], len);
-      n += len;
-    }
-  }
-  return n;
-}
-
-/**
- * @}
- */

src/quickjs/buffer-utils.h

@@ -1,348 +0,0 @@
-#ifndef BUFFER_UTILS_H
-#define BUFFER_UTILS_H
-
-#include <quickjs.h>
-#include <cutils.h>
-#include <stdarg.h>
-
-#include "char-utils.h"
-
-/**
- * \defgroup buffer-utils buffer-utils: Buffer Utilities
- * @{
- */
-int64_t array_search(void* a, size_t m, size_t elsz, void* needle);
-#define array_contains(a, m, elsz, needle) (array_search((a), (m), (elsz), (needle)) != -1)
-
-size_t ansi_length(const char*, size_t);
-size_t ansi_skip(const char*, size_t);
-size_t ansi_truncate(const char*, size_t, size_t limit);
-int64_t array_search(void*, size_t, size_t elsz, void* needle);
-char* str_escape(const char*);
-
-char* byte_escape(const void*, size_t);
-size_t byte_findb(const void*, size_t, const void* what, size_t wlen);
-size_t byte_finds(const void*, size_t, const char* what);
-size_t byte_equal(const void* s, size_t n, const void* t);
-void byte_copy(void* out, size_t len, const void* in);
-void byte_copyr(void* out, size_t len, const void* in);
-size_t byte_rchrs(const char* in, size_t len, const char needles[], size_t nn);
-
-#define DBUF_INIT_0() \
-  (DynBuf) { 0, 0, 0, 0, 0, 0 }
-#define DBUF_INIT_CTX(ctx) \
-  (DynBuf) { 0, 0, 0, 0, (DynBufReallocFunc*)js_realloc_rt, JS_GetRuntime(ctx) }
-
-extern const uint8_t escape_url_tab[256], escape_noquote_tab[256], escape_singlequote_tab[256], escape_doublequote_tab[256], escape_backquote_tab[256];
-
-char* dbuf_at_n(const DynBuf*, size_t, size_t* n, char sep);
-const char* dbuf_last_line(DynBuf*, size_t*);
-int dbuf_prepend(DynBuf*, const uint8_t*, size_t len);
-void dbuf_put_colorstr(DynBuf*, const char*, const char* color, int with_color);
-void dbuf_put_escaped_pred(DynBuf*, const char*, size_t len, int (*pred)(int));
-void dbuf_put_escaped_table(DynBuf*, const char*, size_t len, const uint8_t table[256]);
-void dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]);
-void dbuf_put_unescaped_pred(DynBuf*, const char*, size_t len, int (*pred)());
-void dbuf_put_escaped(DynBuf*, const char*, size_t len);
-void dbuf_put_value(DynBuf*, JSContext*, JSValue value);
-void dbuf_put_uint32(DynBuf* db, uint32_t num);
-void dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom);
-int dbuf_reserve_start(DynBuf*, size_t);
-uint8_t* dbuf_reserve(DynBuf*, size_t);
-size_t dbuf_token_pop(DynBuf*, char);
-size_t dbuf_token_push(DynBuf*, const char*, size_t len, char delim);
-JSValue dbuf_tostring_free(DynBuf*, JSContext*);
-ssize_t dbuf_load(DynBuf*, const char*);
-int dbuf_vprintf(DynBuf*, const char*, va_list);
-
-int screen_size(int size[2]);
-
-static inline int
-dbuf_putm(DynBuf* db, ...) {
-  int r = 0;
-  va_list a;
-  const char* s;
-  va_start(a, db);
-  while((s = va_arg(a, char*)))
-    if(dbuf_putstr(db, s))
-      return -1;
-  va_end(a);
-  return r;
-}
-
-#define dbuf_append(d, x, n) dbuf_put((d), (const uint8_t*)(x), (n))
-
-static inline size_t
-dbuf_count(DynBuf* db, int ch) {
-  return byte_count(db->buf, db->size, ch);
-}
-
-static inline void
-dbuf_0(DynBuf* db) {
-  dbuf_putc(db, '\0');
-  db->size--;
-}
-
-static inline void
-dbuf_zero(DynBuf* db) {
-  dbuf_realloc(db, 0);
-  db->size = 0;
-}
-
-size_t dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]);
-
-#define js_dbuf_init(ctx, buf) dbuf_init2((buf), (ctx), (realloc_func*)&utils_js_realloc)
-#define js_dbuf_init_rt(rt, buf) dbuf_init2((buf), (rt), (realloc_func*)&utils_js_realloc_rt)
-
-void js_dbuf_allocator(JSContext* ctx, DynBuf* s);
-
-typedef struct {
-  uint8_t* base;
-  size_t size;
-} MemoryBlock;
-
-static inline void
-block_init(MemoryBlock* mb) {
-  mb->base = 0;
-  mb->size = 0;
-}
-
-/* clang-format off */
-static inline void* block_data(const MemoryBlock* mb) { return mb->base; }
-static inline size_t block_length(const MemoryBlock* mb) { return mb->size; }
-static inline void* block_begin(const MemoryBlock* mb) { return mb->base; }
-static inline void* block_end(const MemoryBlock* mb) { return mb->base + mb->size; }
-/* clang-format on */
-
-static inline BOOL
-block_arraybuffer(MemoryBlock* mb, JSValueConst ab, JSContext* ctx) {
-  mb->base = JS_GetArrayBuffer(ctx, &mb->size, ab);
-  return mb->base != 0;
-}
-
-typedef struct {
-  uint8_t *start, *end;
-} PointerRange;
-
-static inline void
-range_init(PointerRange* pr) {
-  pr->end = pr->start = 0;
-}
-
-static inline PointerRange
-range_from(const MemoryBlock* mb) {
-  return (PointerRange){mb->base, mb->base + mb->size};
-}
-
-typedef struct {
-  int64_t start, end;
-} IndexRange;
-
-typedef struct {
-  int64_t offset, length;
-} OffsetLength;
-
-#define OFFSET_INIT() \
-  (OffsetLength) { 0, INT64_MAX }
-
-static inline void
-offset_init(OffsetLength* ol) {
-  ol->offset = 0;
-  ol->length = INT64_MAX;
-}
-
-static inline BOOL
-offset_is_default(const OffsetLength* ol) {
-  return ol->offset == 0 && ol->length == INT64_MAX;
-}
-
-static inline void*
-offset_data(const OffsetLength* ol, const void* x) {
-  return (uint8_t*)x + ol->offset;
-}
-
-static inline size_t
-offset_size(const OffsetLength* ol, size_t n) {
-  if(ol->length == -1)
-    return (signed long)n - ol->offset;
-  return MIN_NUM(ol->length, (signed long)n - ol->offset);
-}
-
-static inline MemoryBlock
-offset_block(const OffsetLength* ol, const void* x, size_t n) {
-  return (MemoryBlock){offset_data(ol, x), offset_size(ol, n)};
-}
-
-static inline PointerRange
-offset_range(const OffsetLength* ol, const void* x, size_t n) {
-  MemoryBlock mb = offset_block(ol, x, n);
-  return range_from(&mb);
-}
-
-static inline OffsetLength
-offset_slice(const OffsetLength ol, int64_t start, int64_t end) {
-  if(start < 0)
-    start = ol.length + (start % ol.length);
-  else if(start > ol.length)
-    start = ol.length;
-  if(end < 0)
-    end = ol.length + (end % ol.length);
-  else if(end > ol.length)
-    end = ol.length;
-
-  return (OffsetLength){start, end - start};
-}
-
-static inline OffsetLength
-offset_offset(const OffsetLength* ol, const OffsetLength* by) {
-  OffsetLength ret;
-  ret.offset = ol->offset + by->offset;
-  ret.length = MIN_NUM(by->length, ol->length - by->offset);
-  return ret;
-}
-
-static inline OffsetLength
-offset_from_indexrange(const IndexRange* ir) {
-  OffsetLength ret;
-  ret.offset = ir->start;
-  ret.length = ir->end - ir->start;
-  return ret;
-}
-
-static inline JSValue
-offset_typedarray(OffsetLength* ol, JSValueConst array, JSContext* ctx) {
-  JSValue ret;
-  size_t offset, length;
-
-  ret = JS_GetTypedArrayBuffer(ctx, array, &offset, &length, NULL);
-
-  if(!JS_IsException(ret)) {
-    ol->offset = offset;
-    ol->length = length;
-  }
-
-  return ret;
-}
-
-static inline IndexRange
-indexrange_from_offset(const OffsetLength* ol) {
-  IndexRange ret;
-  ret.start = ol->offset;
-  ret.end = ol->offset + ol->length;
-  return ret;
-}
-
-static inline MemoryBlock
-block_range(const MemoryBlock* mb, const OffsetLength* range) {
-  MemoryBlock ret;
-  ret.base = mb->base + range->offset;
-  ret.size = MIN_NUM((size_t)range->length, mb->size - range->offset);
-  return ret;
-}
-
-static inline int
-block_realloc(MemoryBlock* mb, size_t new_size, JSContext* ctx) {
-  if((mb->base = js_realloc(ctx, mb->base, new_size))) {
-    mb->size = new_size;
-    return 0;
-  }
-  return -1;
-}
-
-typedef struct InputBuffer {
-  union {
-    MemoryBlock block;
-    struct {
-      uint8_t* data;
-      size_t size;
-    };
-  };
-  size_t pos;
-  void (*free)(JSContext*, const char*, JSValue);
-  JSValue value;
-  OffsetLength range;
-} InputBuffer;
-
-static inline void
-input_buffer_free_default(JSContext* ctx, const char* str, JSValue val) {
-  if(JS_IsString(val))
-    JS_FreeCString(ctx, str);
-
-  if(!JS_IsUndefined(val))
-    JS_FreeValue(ctx, val);
-}
-
-InputBuffer js_input_buffer(JSContext* ctx, JSValueConst value);
-InputBuffer js_input_chars(JSContext* ctx, JSValueConst value);
-InputBuffer js_input_args(JSContext* ctx, int argc, JSValueConst argv[]);
-InputBuffer js_output_args(JSContext* ctx, int argc, JSValueConst argv[]);
-
-InputBuffer input_buffer_clone(const InputBuffer* in, JSContext* ctx);
-BOOL input_buffer_valid(const InputBuffer* in);
-void input_buffer_dump(const InputBuffer* in, DynBuf* db);
-void input_buffer_free(InputBuffer* in, JSContext* ctx);
-
-static inline uint8_t*
-input_buffer_data(const InputBuffer* in) {
-  return offset_data(&in->range, in->data);
-}
-
-static inline size_t
-input_buffer_length(const InputBuffer* in) {
-  return offset_size(&in->range, in->size);
-}
-
-static inline MemoryBlock
-input_buffer_block(InputBuffer* in) {
-  return (MemoryBlock){input_buffer_data(in), input_buffer_length(in)};
-}
-
-static inline MemoryBlock*
-input_buffer_blockptr(InputBuffer* in) {
-  return &in->block;
-}
-
-const uint8_t* input_buffer_get(InputBuffer* in, size_t* lenp);
-const uint8_t* input_buffer_peek(InputBuffer* in, size_t* lenp);
-const char* input_buffer_currentline(InputBuffer*, size_t* len);
-size_t input_buffer_column(InputBuffer*, size_t* len);
-
-int input_buffer_peekc(InputBuffer* in, size_t* lenp);
-int input_buffer_putc(InputBuffer*, unsigned int, JSContext*);
-
-static inline int
-input_buffer_getc(InputBuffer* in) {
-  size_t n;
-  int ret;
-  ret = input_buffer_peekc(in, &n);
-  in->pos += n;
-  return ret;
-}
-
-static inline void*
-input_buffer_begin(const InputBuffer* in) {
-  return input_buffer_data(in);
-}
-
-static inline void*
-input_buffer_end(const InputBuffer* in) {
-  return input_buffer_data(in) + input_buffer_length(in);
-}
-
-static inline BOOL
-input_buffer_eof(const InputBuffer* in) {
-  return in->pos == input_buffer_length(in);
-}
-
-static inline size_t
-input_buffer_remain(const InputBuffer* in) {
-  return input_buffer_length(in) - in->pos;
-}
-
-int js_offset_length(JSContext*, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p);
-int js_index_range(JSContext*, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p);
-
-/**
- * @}
- */
-#endif /* defined(BUFFER_UTILS) */

src/quickjs/char-utils.c

@@ -1,578 +0,0 @@
-#include "char-utils.h"
-#include "libutf.h"
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
-#include <winnls.h>
-#include <windows.h>
-#include <wchar.h>
-#endif
-
-/**
- * \addtogroup char-utils
- * @{
- */
-size_t
-token_length(const char* str, size_t len, char delim) {
-  const char *s, *e;
-  size_t pos;
-
-  for(s = str, e = s + len; s < e; s += pos + 1) {
-    pos = byte_chr(s, e - s, delim);
-
-    if(s + pos == e)
-      break;
-
-    if(pos == 0 || s[pos - 1] != '\\') {
-      s += pos;
-      break;
-    }
-  }
-
-  return s - str;
-}
-
-size_t
-fmt_ulong(char* dest, uint32_t i) {
-  uint32_t len, tmp, len2;
-
-  for(len = 1, tmp = i; tmp > 9; ++len)
-    tmp /= 10;
-
-  if(dest)
-    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
-      *--dest = (char)((tmp % 10) + '0');
-
-  return len;
-}
-
-size_t
-fmt_longlong(char* dest, int64_t i) {
-  if(i < 0) {
-    if(dest)
-      *dest++ = '-';
-    return fmt_ulonglong(dest, (uint64_t)-i) + 1;
-  }
-
-  return fmt_ulonglong(dest, (uint64_t)i);
-}
-
-size_t
-fmt_ulonglong(char* dest, uint64_t i) {
-  size_t len;
-  uint64_t tmp, len2;
-
-  for(len = 1, tmp = i; tmp > 9ll; ++len)
-    tmp /= 10ll;
-
-  if(dest)
-    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10ll)
-      *--dest = (tmp % 10ll) + '0';
-
-  return len;
-}
-
-#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
-
-size_t
-fmt_xlonglong(char* dest, uint64_t i) {
-  uint64_t len, tmp;
-
-  for(len = 1, tmp = i; tmp > 15ll; ++len)
-    tmp >>= 4ll;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = tohex(tmp & 15ll);
-
-      if(!(tmp >>= 4ll))
-        break;
-    }
-
-  return len;
-}
-
-size_t
-fmt_xlonglong0(char* dest, uint64_t num, size_t n) {
-  size_t i = 0, len;
-
-  if((len = fmt_xlonglong(NULL, num)) < n) {
-    len = n - len;
-
-    while(i < len)
-      dest[i++] = '0';
-  }
-
-  i += fmt_xlonglong(&dest[i], num);
-  return i;
-}
-
-size_t
-fmt_8long(char* dest, uint32_t i) {
-  uint32_t len, tmp;
-
-  /* first count the number of bytes needed */
-  for(len = 1, tmp = i; tmp > 7; ++len)
-    tmp >>= 3;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = (char)((tmp & 7) + '0');
-
-      if(!(tmp >>= 3))
-        break;
-    }
-
-  return len;
-}
-
-#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
-
-size_t
-fmt_xlong(char* dest, uint32_t i) {
-  uint32_t len, tmp;
-
-  /* first count the number of bytes needed */
-  for(len = 1, tmp = i; tmp > 15; ++len)
-    tmp >>= 4;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = tohex(tmp & 15);
-
-      if(!(tmp >>= 4))
-        break;
-    }
-
-  return len;
-}
-
-size_t
-fmt_xlong0(char* dest, uint32_t num, size_t n) {
-  size_t i = 0, len;
-
-  if((len = fmt_xlong(NULL, num)) < n) {
-    len = n - len;
-
-    while(i < len)
-      dest[i++] = '0';
-  }
-
-  i += fmt_xlong(&dest[i], num);
-  return i;
-}
-
-size_t
-scan_ushort(const char* src, uint16_t* dest) {
-  const char* cur;
-  uint16_t l;
-
-  for(cur = src, l = 0; *cur >= '0' && *cur <= '9'; ++cur) {
-    uint32_t tmp = l * 10ul + *cur - '0';
-
-    if((uint16_t)tmp != tmp)
-      break;
-
-    l = tmp;
-  }
-
-  if(cur > src)
-    *dest = l;
-
-  return (size_t)(cur - src);
-}
-
-size_t
-scan_uint(const char* src, uint32_t* dest) {
-  uint64_t u64;
-  size_t r = scan_ulonglong(src, &u64);
-  *dest = u64;
-  return r;
-}
-
-size_t
-scan_int(const char* src, int32_t* dest) {
-  int64_t i64;
-  size_t r = scan_longlong(src, &i64);
-  *dest = i64;
-  return r;
-}
-
-#ifndef MAXLONG
-#define MAXLONG (((uint32_t)-1) >> 1)
-#endif
-
-size_t
-scan_longlong(const char* src, int64_t* dest) {
-  size_t i, o;
-  uint64_t l;
-  char c = src[0];
-  unsigned int neg = c == '-';
-  o = c == '-' || c == '+';
-
-  if((i = scan_ulonglong(src + o, &l))) {
-    if(i > 0ll && l > MAXLONG + neg) {
-      l /= 10ll;
-      --i;
-    }
-
-    if(i + o)
-      *dest = (int64_t)(c == '-' ? -l : l);
-
-    return i + o;
-  }
-
-  return 0;
-}
-
-size_t
-scan_ulonglong(const char* src, uint64_t* dest) {
-  const char* tmp = src;
-  uint64_t l = 0;
-  unsigned char c;
-
-  while((c = (unsigned char)(*tmp - '0')) < 10) {
-    uint64_t n;
-    n = l << 3ll;
-
-    if((n >> 3ll) != l)
-      break;
-
-    if(n + (l << 1ll) < n)
-      break;
-
-    n += l << 1ll;
-
-    if(n + c < n)
-      break;
-
-    l = n + c;
-    ++tmp;
-  }
-
-  if(tmp - src)
-    *dest = l;
-
-  return (size_t)(tmp - src);
-}
-
-size_t
-scan_xlonglong(const char* src, uint64_t* dest) {
-  const char* tmp = src;
-  int64_t l = 0;
-  unsigned char c;
-
-  while((c = scan_fromhex(*tmp)) < 16) {
-    l = (l << 4) + c;
-    ++tmp;
-  }
-
-  *dest = l;
-  return tmp - src;
-}
-
-size_t
-scan_8longn(const char* src, size_t n, uint32_t* dest) {
-  const char* tmp = src;
-  uint32_t l = 0;
-  unsigned char c;
-
-  while(n-- > 0 && (c = (unsigned char)(*tmp - '0')) < 8) {
-    if(l >> (sizeof(l) * 8 - 3))
-      break;
-
-    l = l * 8 + c;
-    ++tmp;
-  }
-
-  *dest = l;
-  return (size_t)(tmp - src);
-}
-
-size_t
-scan_whitenskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = t + limit; t < u; ++t)
-    if(!is_whitespace_char(*t))
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_nonwhitenskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = t + limit; t < u; ++t)
-    if(is_whitespace_char(*t))
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_line(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t)
-    if(*t == '\n' || *t == '\r')
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_lineskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t)
-    if(*t == '\n') {
-      ++t;
-      break;
-    }
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_lineskip_escaped(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t) {
-    if(*t == '\\') {
-      ++t;
-      continue;
-    }
-    if(*t == '\n') {
-      ++t;
-      break;
-    }
-  }
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_eolskip(const char* s, size_t limit) {
-  size_t n = 0;
-
-  if(n + 1 < limit && s[0] == '\r' && s[1] == '\n')
-    n += 2;
-  else if(n < limit && s[0] == '\n')
-    n += 1;
-
-  return n;
-}
-
-size_t
-utf8_strlen(const void* in, size_t len) {
-  const uint8_t *pos, *end, *next;
-  size_t i = 0;
-
-  for(pos = (const uint8_t*)in, end = pos + len; pos < end; pos = next, ++i)
-    unicode_from_utf8(pos, end - pos, &next);
-
-  return i;
-}
-
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
-wchar_t*
-utf8_towcs(const char* s) {
-  int len = (int)strlen(s);
-  int n = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
-  wchar_t* ret;
-
-  if((ret = (wchar_t*)malloc((n + 1) * sizeof(wchar_t)))) {
-    MultiByteToWideChar(CP_UTF8, 0, s, len, ret, n);
-    ret[n] = L'\0';
-  }
-
-  return ret;
-}
-
-char*
-utf8_fromwcs(const wchar_t* wstr) {
-  int len = (int)wcslen(wstr);
-  int n = WideCharToMultiByte(CP_UTF8, 0, wstr, len, NULL, 0, NULL, NULL);
-  char* ret;
-
-  if((ret = malloc((n + 1)))) {
-    WideCharToMultiByte(CP_UTF8, 0, wstr, len, ret, n, NULL, NULL);
-    ret[n] = '\0';
-  }
-
-  return ret;
-}
-#endif
-
-BOOL
-utf16_multiword(const void* in) {
-  const uint16_t* p16 = in;
-  LibutfC16Type type = libutf_c16_type(p16[0]);
-
-  return !((LIBUTF_UTF16_NOT_SURROGATE == type) || (LIBUTF_UTF16_SURROGATE_HIGH != type || LIBUTF_UTF16_SURROGATE_LOW != libutf_c16_type(p16[1])));
-}
-
-int
-case_lowerc(int c) {
-  if(c >= 'A' && c <= 'Z')
-    c += 'a' - 'A';
-
-  return c;
-}
-
-int
-case_starts(const char* a, const char* b) {
-  const char *s, *t;
-
-  for(s = a, t = b;; ++s, ++t) {
-    unsigned char x, y;
-
-    if(!*t)
-      return 1;
-
-    x = case_lowerc(*s);
-    y = case_lowerc(*t);
-
-    if(x != y)
-      break;
-
-    if(!x)
-      break;
-  }
-
-  return 0;
-}
-
-int
-case_diffb(const void* S, size_t len, const void* T) {
-  unsigned char x, y;
-  const char *s, *t;
-
-  for(s = (const char*)S, t = (const char*)T; len > 0;) {
-    --len;
-    x = case_lowerc(*s);
-    y = case_lowerc(*t);
-
-    ++s;
-    ++t;
-
-    if(x != y)
-      return ((int)(unsigned int)x) - ((int)(unsigned int)y);
-  }
-
-  return 0;
-}
-
-size_t
-case_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
-  size_t i, last;
-  const char* s = haystack;
-
-  if(hlen < wlen)
-    return hlen;
-
-  last = hlen - wlen;
-
-  for(i = 0; i <= last; i++, s++)
-    if(!case_diffb(s, wlen, what))
-      return i;
-
-  return hlen;
-}
-
-size_t
-case_finds(const void* haystack, const char* what) {
-  return case_findb(haystack, strlen(haystack), what, strlen(what));
-}
-
-ssize_t
-write_file(const char* file, const void* buf, size_t len) {
-  FILE* f;
-  ssize_t ret = -1;
-
-  if((f = fopen(file, "w+")))
-    switch(fwrite(buf, len, 1, f)) {
-      case 1: {
-        ret = len;
-        break;
-      }
-    }
-
-  fflush(f);
-  ret = ftell(f);
-  fclose(f);
-
-  return ret;
-}
-
-ssize_t
-puts_file(const char* file, const char* s) {
-  return write_file(file, s, strlen(s));
-}
-
-size_t
-u64toa(char* x, uint64_t num, int base) {
-  size_t len = 0;
-  uint64_t n = num;
-
-  do {
-    n /= base;
-    len++;
-    x++;
-  } while(n != 0);
-
-  *x-- = '\0';
-
-  do {
-    char c = num % base;
-    num /= base;
-
-    if(c >= 10)
-      c += 'a' - '0' - 10;
-    *x-- = c + '0';
-  } while(num != 0);
-
-  return len;
-}
-
-size_t
-i64toa(char* x, int64_t num, int base) {
-  size_t pos = 0, len;
-
-  if(num < 0) {
-    x[pos++] = '-';
-    num = -num;
-  }
-
-  len = u64toa(&x[pos], num, base);
-
-  return pos + len;
-}
-
-size_t
-str_findb(const char* s1, const char* x, size_t n) {
-  const char* b;
-  size_t i, j, len = strlen(s1);
-
-  if(len >= n) {
-    size_t end = len - n + 1;
-
-    for(i = 0; i < end; i++) {
-      b = &s1[i];
-
-      for(j = 0; x[j] == b[j];)
-        if(++j == n)
-          return i;
-    }
-  }
-
-  return len;
-}
-
-size_t
-str_find(const void* s, const void* what) {
-  return str_findb(s, what, strlen(what));
-}
-/**
- * @}
- */

src/quickjs/char-utils.h

@@ -1,441 +0,0 @@
-#ifndef CHAR_UTILS_H
-#define CHAR_UTILS_H
-
-#include <cutils.h>
-#include <string.h>
-#include "debug.h"
-
-/**
- * \defgroup char-utils char-utils: Character Utilities
- * @{
- */
-#define is_control_char(c) ((c) == '\a' || (c) == '\b' || (c) == '\t' || (c) == '\n' || (c) == '\v' || (c) == '\f' || (c) == '\r')
-#define is_alphanumeric_char(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
-
-#define is_digit_char(c) ((c) >= '0' && (c) <= '9')
-#define is_print_char(c) ((c) >= ' ' && (c) <= '\x7f')
-#define is_newline_char(c) ((c) == '\n')
-#define is_identifier_char(c) (is_alphanumeric_char(c) || is_digit_char(c) || (c) == '$' || (c) == '_')
-#define is_whitespace_char(c) ((c) == ' ' || (c) == '\t' || (c) == '\v' || (c) == '\n' || (c) == '\r')
-
-#define str_equal(s, t) (!strcmp((s), (t)))
-
-static inline int
-escape_char_pred(int c) {
-  static const unsigned char table[256] = {
-      'x', 'x', 'x', 'x', 'x', 'x',  'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-      'x', 'x', 'x', 0,   0,   0,    0,   0,   0,    0,    0x27, 0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0x5c, 0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    'x',  0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  };
-
-  return table[(unsigned char)c];
-}
-
-static inline int
-unescape_char_pred(int c) {
-  switch(c) {
-    case 'b': return 8;
-    case 'f': return 12;
-    case 'n': return 10;
-    case 'r': return 13;
-    case 't': return 9;
-    case 'v': return 11;
-    case '\'': return 39;
-    case '\\': return 92;
-  }
-
-  return 0;
-}
-
-static inline int
-is_escape_char(int c) {
-  return is_control_char(c) || c == '\\' || c == '\'' || c == 0x1b || c == 0;
-}
-
-static inline int
-is_backslash_char(int c) {
-  return c == '\\';
-}
-
-//#define is_dot_char(c) ((c) == '.')0
-//#define is_backslash_char(c) ((c) == '\\')
-
-static inline int
-is_dot_char(int c) {
-  return c == '.';
-}
-
-static inline int
-is_identifier(const char* str) {
-  if(!((*str >= 'A' && *str <= 'Z') || (*str >= 'a' && *str <= 'z') || *str == '$' || *str == '_'))
-    return 0;
-
-  while(*++str)
-    if(!is_identifier_char(*str))
-      return 0;
-
-  return 1;
-}
-
-static inline int
-is_integer(const char* str) {
-  if(*str == '-')
-    ++str;
-
-  if(!(*str >= '1' && *str <= '9') && !(*str == '0' && str[1] == '\0'))
-    return 0;
-
-  while(*++str)
-    if(!is_digit_char(*str))
-      return 0;
-
-  return 1;
-}
-
-static inline size_t
-byte_count(const void* s, size_t n, char c) {
-  const uint8_t* t;
-  uint8_t ch = (uint8_t)c;
-  size_t count;
-
-  for(t = (uint8_t*)s, count = 0; n; ++t, --n)
-    if(*t == ch)
-      ++count;
-
-  return count;
-}
-
-static inline size_t
-byte_chr(const void* str, size_t len, char c) {
-  const char* s = memchr(str, c, len);
-
-  if(s)
-    return s - (const char*)str;
-
-  return len;
-}
-
-static inline size_t
-byte_rchr(const void* haystack, size_t len, char needle) {
-  const char *s, *t;
-
-  for(s = (const char*)haystack, t = s + len;;) {
-    --t;
-
-    if(s > t)
-      break;
-
-    if(*t == needle)
-      return (size_t)(t - s);
-  }
-
-  return len;
-}
-
-/*size_t
-byte_rchr(const void* str, size_t len, char c) {
-  const char* s = memrchr(str, c, len);
-  if(s)
-    return s - (const char*)str;
-  return len;
-}*/
-
-static inline size_t
-byte_chrs(const void* str, size_t len, const char needle[], size_t nl) {
-  const char *s, *t;
-
-  for(s = str, t = s + len; s != t; s++)
-    if(byte_chr(needle, nl, *s) < nl)
-      break;
-
-  return s - (const char*)str;
-}
-
-static inline int
-byte_diff(const void* a, size_t len, const void* b) {
-  size_t i;
-
-  for(i = 0; i < len; ++i) {
-    int r = ((unsigned char*)a)[i] - ((unsigned char*)b)[i];
-
-    if(r)
-      return r;
-  }
-
-  return 0;
-}
-
-static inline int
-byte_diff2(const char* a, size_t alen, const char* b, size_t blen) {
-
-  if(alen < blen)
-    return -b[alen];
-
-  if(blen < alen)
-    return a[blen];
-
-  return byte_diff(a, alen, b);
-}
-
-static inline size_t
-str_chr(const char* in, char needle) {
-  const char *t, c = needle;
-
-  for(t = in; *t; ++t)
-    if(*t == c)
-      break;
-
-  return (size_t)(t - in);
-}
-
-static inline size_t
-str_chrs(const char* in, const char needles[], size_t nn) {
-  const char* t;
-  size_t i;
-
-  for(t = in; *t; ++t)
-    for(i = 0; i < nn; i++)
-      if(*t == needles[i])
-        return (size_t)(t - in);
-
-  return (size_t)(t - in);
-}
-
-static inline size_t
-str_rchr(const char* s, char needle) {
-  const char *in, *found = 0;
-
-  for(in = s; *in; ++in)
-    if(*in == needle)
-      found = in;
-
-  return (size_t)((found ? found : in) - s);
-}
-
-static inline size_t
-str_rchrs(const char* in, const char needles[], size_t nn) {
-  const char *s, *found = 0;
-  size_t i;
-
-  for(s = in; *s; ++s)
-    for(i = 0; i < nn; ++i)
-      if(*s == needles[i])
-        found = s;
-
-  return (size_t)((found ? found : s) - in);
-}
-
-static inline int
-str_endb(const char* a, const char* x, size_t n) {
-  size_t alen = strlen(a);
-  a += alen - n;
-
-  return alen >= n && !memcmp(a, x, n);
-}
-
-/* str_ends returns 1 if the b is a suffix of a, 0 otherwise */
-static inline int
-str_ends(const char* a, const char* b) {
-  return str_endb(a, b, strlen(b));
-}
-
-static inline int
-str_startb(const char* a, const char* x, size_t len) {
-  size_t i;
-
-  for(i = 0;; i++) {
-    if(i == len)
-      return 1;
-    if(a[i] != x[i])
-      break;
-  }
-
-  return 0;
-}
-
-static inline int
-str_start(const char* a, const char* b) {
-  return str_startb(a, b, strlen(b));
-}
-
-#define str_contains(s, needle) (!!strchr((s), (needle)))
-
-char* str_escape(const char*);
-
-static inline size_t
-str_count(const char* s, char c) {
-  size_t i, count = 0;
-
-  for(i = 0; s[i]; i++)
-    if(s[i] == c)
-      ++count;
-
-  return count;
-}
-
-static inline size_t
-str_copy(char* out, const char* in) {
-  char* s;
-
-  for(s = out; (*s = *in); ++s)
-    ++in;
-
-  return (size_t)(s - out);
-}
-
-static inline size_t
-str_copyn(char* out, const char* in, size_t n) {
-  char* s;
-
-  for(s = out; n-- && (*s = *in); ++s)
-    ++in;
-
-  *s = '\0';
-  return (size_t)(s - out);
-}
-
-static inline char*
-str_ndup(const char* s, size_t n) {
-  char* r = malloc(n + 1);
-
-  if(r == NULL)
-    return NULL;
-
-  memcpy(r, s, n);
-  r[n] = '\0';
-  return r;
-}
-
-size_t str_findb(const char*, const char*, size_t);
-size_t str_find(const void*, const void*);
-
-static inline size_t
-predicate_find(const char* str, size_t len, int (*pred)(int32_t)) {
-  size_t pos;
-
-  for(pos = 0; pos < len; pos++)
-    if(pred(str[pos]))
-      break;
-
-  return pos;
-}
-
-static inline size_t
-lookup_find(const char* str, size_t len, const char table[256]) {
-  size_t pos;
-
-  for(pos = 0; pos < len; pos++)
-    if(table[(unsigned char)str[pos]])
-      break;
-
-  return pos;
-}
-
-static inline char
-escape_char_letter(char c) {
-  switch(c) {
-    case '\0': return '0';
-    case '\a': return 'a';
-    case '\b': return 'b';
-    case '\t': return 't';
-    case '\n': return 'n';
-    case '\v': return 'v';
-    case '\f': return 'f';
-    case '\r': return 'r';
-    case '\\': return '\\';
-    case '\'': return '\'';
-  }
-
-  return 0;
-}
-
-#define FMT_LONG 41  /* enough space to hold -2^127 in decimal, plus \0 */
-#define FMT_ULONG 40 /* enough space to hold 2^128 - 1 in decimal, plus \0 */
-#define FMT_8LONG 44 /* enough space to hold 2^128 - 1 in octal, plus \0 */
-#define FMT_XLONG 33 /* enough space to hold 2^128 - 1 in hexadecimal, plus \0 */
-
-size_t token_length(const char*, size_t, char delim);
-size_t fmt_ulong(char*, uint32_t);
-size_t scan_ushort(const char*, uint16_t*);
-size_t fmt_longlong(char*, int64_t);
-size_t fmt_ulonglong(char*, uint64_t);
-size_t fmt_xlonglong(char*, uint64_t);
-size_t fmt_xlonglong0(char*, uint64_t, size_t);
-size_t fmt_8long(char* dest, uint32_t i);
-size_t fmt_xlong(char* dest, uint32_t num);
-size_t fmt_xlong0(char* dest, uint32_t num, size_t n);
-size_t scan_longlong(const char*, int64_t*);
-size_t scan_int(const char*, int32_t*);
-size_t scan_uint(const char*, uint32_t*);
-size_t scan_ulonglong(const char*, uint64_t*);
-size_t scan_xlonglong(const char*, uint64_t*);
-size_t scan_8longn(const char*, size_t, uint32_t* dest);
-size_t scan_whitenskip(const char*, size_t);
-size_t scan_nonwhitenskip(const char*, size_t);
-size_t scan_line(const char*, size_t);
-size_t scan_lineskip(const char*, size_t);
-size_t scan_lineskip_escaped(const char*, size_t);
-size_t scan_eolskip(const char*, size_t);
-size_t utf8_strlen(const void*, size_t);
-wchar_t* utf8_towcs(const char*);
-char* utf8_fromwcs(const wchar_t*);
-BOOL utf16_multiword(const void*);
-int case_lowerc(int);
-int case_starts(const char*, const char*);
-int case_diffb(const void*, size_t, const void* T);
-size_t case_findb(const void*, size_t, const void* what, size_t wlen);
-size_t case_finds(const void*, const char*);
-
-static inline int
-scan_fromhex(unsigned char c) {
-  c -= '0';
-
-  if(c <= 9)
-    return c;
-
-  c &= ~0x20;
-  c -= 'A' - '0';
-
-  if(c < 6)
-    return c + 10;
-
-  return -1;
-}
-
-static inline size_t
-scan_8long(const char* src, uint32_t* dest) {
-  return scan_8longn(src, (size_t)-1, dest);
-}
-
-static inline size_t
-utf8_charlen(const char* in, size_t len) {
-  const uint8_t* next = (const void*)in;
-  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
-  return r == -1 ? 0 : next - (const uint8_t*)in;
-}
-
-static inline int
-utf8_charcode(const char* in, size_t len) {
-  const uint8_t* next = (const void*)in;
-  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
-  return next > in ? r : -1;
-}
-
-BOOL utf16_multiword(const void*);
-
-ssize_t write_file(const char* file, const void* buf, size_t len);
-ssize_t puts_file(const char* file, const char* s);
-
-size_t u64toa(char*, uint64_t num, int base);
-size_t i64toa(char*, int64_t num, int base);
-
-/**
- * @}
- */
-#endif /* defined(CHAR_UTILS_H) */

src/quickjs/cutils.c

@@ -1,631 +0,0 @@
-/*
- * C utilities
- *
- * Copyright (c) 2017 Fabrice Bellard
- * Copyright (c) 2018 Charlie Gordon
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include "cutils.h"
-
-void pstrcpy(char *buf, int buf_size, const char *str)
-{
-    int c;
-    char *q = buf;
-
-    if (buf_size <= 0)
-        return;
-
-    for(;;) {
-        c = *str++;
-        if (c == 0 || q >= buf + buf_size - 1)
-            break;
-        *q++ = c;
-    }
-    *q = '\0';
-}
-
-/* strcat and truncate. */
-char *pstrcat(char *buf, int buf_size, const char *s)
-{
-    int len;
-    len = strlen(buf);
-    if (len < buf_size)
-        pstrcpy(buf + len, buf_size - len, s);
-    return buf;
-}
-
-int strstart(const char *str, const char *val, const char **ptr)
-{
-    const char *p, *q;
-    p = str;
-    q = val;
-    while (*q != '\0') {
-        if (*p != *q)
-            return 0;
-        p++;
-        q++;
-    }
-    if (ptr)
-        *ptr = p;
-    return 1;
-}
-
-int has_suffix(const char *str, const char *suffix)
-{
-    size_t len = strlen(str);
-    size_t slen = strlen(suffix);
-    return (len >= slen && !memcmp(str + len - slen, suffix, slen));
-}
-
-/* Dynamic buffer package */
-
-static void *dbuf_default_realloc(void *opaque, void *ptr, size_t size)
-{
-    return realloc(ptr, size);
-}
-
-void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func)
-{
-    memset(s, 0, sizeof(*s));
-    if (!realloc_func)
-        realloc_func = dbuf_default_realloc;
-    s->opaque = opaque;
-    s->realloc_func = realloc_func;
-}
-
-void dbuf_init(DynBuf *s)
-{
-    dbuf_init2(s, NULL, NULL);
-}
-
-/* return < 0 if error */
-int dbuf_realloc(DynBuf *s, size_t new_size)
-{
-    size_t size;
-    uint8_t *new_buf;
-    if (new_size > s->allocated_size) {
-        if (s->error)
-            return -1;
-        size = s->allocated_size * 3 / 2;
-        if (size > new_size)
-            new_size = size;
-        new_buf = s->realloc_func(s->opaque, s->buf, new_size);
-        if (!new_buf) {
-            s->error = TRUE;
-            return -1;
-        }
-        s->buf = new_buf;
-        s->allocated_size = new_size;
-    }
-    return 0;
-}
-
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len)
-{
-    size_t end;
-    end = offset + len;
-    if (dbuf_realloc(s, end))
-        return -1;
-    memcpy(s->buf + offset, data, len);
-    if (end > s->size)
-        s->size = end;
-    return 0;
-}
-
-int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
-{
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
-            return -1;
-    }
-    memcpy_no_ub(s->buf + s->size, data, len);
-    s->size += len;
-    return 0;
-}
-
-int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
-{
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
-            return -1;
-    }
-    memcpy(s->buf + s->size, s->buf + offset, len);
-    s->size += len;
-    return 0;
-}
-
-int dbuf_putc(DynBuf *s, uint8_t c)
-{
-    return dbuf_put(s, &c, 1);
-}
-
-int dbuf_putstr(DynBuf *s, const char *str)
-{
-    return dbuf_put(s, (const uint8_t *)str, strlen(str));
-}
-
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...)
-{
-    va_list ap;
-    char buf[128];
-    int len;
-
-    va_start(ap, fmt);
-    len = vsnprintf(buf, sizeof(buf), fmt, ap);
-    va_end(ap);
-    if (len < sizeof(buf)) {
-        /* fast case */
-        return dbuf_put(s, (uint8_t *)buf, len);
-    } else {
-        if (dbuf_realloc(s, s->size + len + 1))
-            return -1;
-        va_start(ap, fmt);
-        vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
-                  fmt, ap);
-        va_end(ap);
-        s->size += len;
-    }
-    return 0;
-}
-
-void dbuf_free(DynBuf *s)
-{
-    /* we test s->buf as a fail safe to avoid crashing if dbuf_free()
-       is called twice */
-    if (s->buf) {
-        s->realloc_func(s->opaque, s->buf, 0);
-    }
-    memset(s, 0, sizeof(*s));
-}
-
-/* Note: at most 31 bits are encoded. At most UTF8_CHAR_LEN_MAX bytes
-   are output. */
-int unicode_to_utf8(uint8_t *buf, unsigned int c)
-{
-    uint8_t *q = buf;
-
-    if (c < 0x80) {
-        *q++ = c;
-    } else {
-        if (c < 0x800) {
-            *q++ = (c >> 6) | 0xc0;
-        } else {
-            if (c < 0x10000) {
-                *q++ = (c >> 12) | 0xe0;
-            } else {
-                if (c < 0x00200000) {
-                    *q++ = (c >> 18) | 0xf0;
-                } else {
-                    if (c < 0x04000000) {
-                        *q++ = (c >> 24) | 0xf8;
-                    } else if (c < 0x80000000) {
-                        *q++ = (c >> 30) | 0xfc;
-                        *q++ = ((c >> 24) & 0x3f) | 0x80;
-                    } else {
-                        return 0;
-                    }
-                    *q++ = ((c >> 18) & 0x3f) | 0x80;
-                }
-                *q++ = ((c >> 12) & 0x3f) | 0x80;
-            }
-            *q++ = ((c >> 6) & 0x3f) | 0x80;
-        }
-        *q++ = (c & 0x3f) | 0x80;
-    }
-    return q - buf;
-}
-
-static const unsigned int utf8_min_code[5] = {
-    0x80, 0x800, 0x10000, 0x00200000, 0x04000000,
-};
-
-static const unsigned char utf8_first_code_mask[5] = {
-    0x1f, 0xf, 0x7, 0x3, 0x1,
-};
-
-/* return -1 if error. *pp is not updated in this case. max_len must
-   be >= 1. The maximum length for a UTF8 byte sequence is 6 bytes. */
-int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
-{
-    int l, c, b, i;
-
-    c = *p++;
-    if (c < 0x80) {
-        *pp = p;
-        return c;
-    }
-    switch(c) {
-    case 0xc0: case 0xc1: case 0xc2: case 0xc3:
-    case 0xc4: case 0xc5: case 0xc6: case 0xc7:
-    case 0xc8: case 0xc9: case 0xca: case 0xcb:
-    case 0xcc: case 0xcd: case 0xce: case 0xcf:
-    case 0xd0: case 0xd1: case 0xd2: case 0xd3:
-    case 0xd4: case 0xd5: case 0xd6: case 0xd7:
-    case 0xd8: case 0xd9: case 0xda: case 0xdb:
-    case 0xdc: case 0xdd: case 0xde: case 0xdf:
-        l = 1;
-        break;
-    case 0xe0: case 0xe1: case 0xe2: case 0xe3:
-    case 0xe4: case 0xe5: case 0xe6: case 0xe7:
-    case 0xe8: case 0xe9: case 0xea: case 0xeb:
-    case 0xec: case 0xed: case 0xee: case 0xef:
-        l = 2;
-        break;
-    case 0xf0: case 0xf1: case 0xf2: case 0xf3:
-    case 0xf4: case 0xf5: case 0xf6: case 0xf7:
-        l = 3;
-        break;
-    case 0xf8: case 0xf9: case 0xfa: case 0xfb:
-        l = 4;
-        break;
-    case 0xfc: case 0xfd:
-        l = 5;
-        break;
-    default:
-        return -1;
-    }
-    /* check that we have enough characters */
-    if (l > (max_len - 1))
-        return -1;
-    c &= utf8_first_code_mask[l - 1];
-    for(i = 0; i < l; i++) {
-        b = *p++;
-        if (b < 0x80 || b >= 0xc0)
-            return -1;
-        c = (c << 6) | (b & 0x3f);
-    }
-    if (c < utf8_min_code[l - 1])
-        return -1;
-    *pp = p;
-    return c;
-}
-
-#if 0
-
-#if defined(EMSCRIPTEN) || defined(__ANDROID__)
-
-static void *rqsort_arg;
-static int (*rqsort_cmp)(const void *, const void *, void *);
-
-static int rqsort_cmp2(const void *p1, const void *p2)
-{
-    return rqsort_cmp(p1, p2, rqsort_arg);
-}
-
-/* not reentrant, but not needed with emscripten */
-void rqsort(void *base, size_t nmemb, size_t size,
-            int (*cmp)(const void *, const void *, void *),
-            void *arg)
-{
-    rqsort_arg = arg;
-    rqsort_cmp = cmp;
-    qsort(base, nmemb, size, rqsort_cmp2);
-}
-
-#endif
-
-#else
-
-typedef void (*exchange_f)(void *a, void *b, size_t size);
-typedef int (*cmp_f)(const void *, const void *, void *opaque);
-
-static void exchange_bytes(void *a, void *b, size_t size) {
-    uint8_t *ap = (uint8_t *)a;
-    uint8_t *bp = (uint8_t *)b;
-
-    while (size-- != 0) {
-        uint8_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_byte(void *a, void *b, size_t size) {
-    uint8_t *ap = (uint8_t *)a;
-    uint8_t *bp = (uint8_t *)b;
-    uint8_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int16s(void *a, void *b, size_t size) {
-    uint16_t *ap = (uint16_t *)a;
-    uint16_t *bp = (uint16_t *)b;
-
-    for (size /= sizeof(uint16_t); size-- != 0;) {
-        uint16_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int16(void *a, void *b, size_t size) {
-    uint16_t *ap = (uint16_t *)a;
-    uint16_t *bp = (uint16_t *)b;
-    uint16_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int32s(void *a, void *b, size_t size) {
-    uint32_t *ap = (uint32_t *)a;
-    uint32_t *bp = (uint32_t *)b;
-
-    for (size /= sizeof(uint32_t); size-- != 0;) {
-        uint32_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int32(void *a, void *b, size_t size) {
-    uint32_t *ap = (uint32_t *)a;
-    uint32_t *bp = (uint32_t *)b;
-    uint32_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int64s(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-
-    for (size /= sizeof(uint64_t); size-- != 0;) {
-        uint64_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int64(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-    uint64_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int128s(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-
-    for (size /= sizeof(uint64_t) * 2; size-- != 0; ap += 2, bp += 2) {
-        uint64_t t = ap[0];
-        uint64_t u = ap[1];
-        ap[0] = bp[0];
-        ap[1] = bp[1];
-        bp[0] = t;
-        bp[1] = u;
-    }
-}
-
-static void exchange_one_int128(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-    uint64_t t = ap[0];
-    uint64_t u = ap[1];
-    ap[0] = bp[0];
-    ap[1] = bp[1];
-    bp[0] = t;
-    bp[1] = u;
-}
-
-static inline exchange_f exchange_func(const void *base, size_t size) {
-    switch (((uintptr_t)base | (uintptr_t)size) & 15) {
-    case 0:
-        if (size == sizeof(uint64_t) * 2)
-            return exchange_one_int128;
-        else
-            return exchange_int128s;
-    case 8:
-        if (size == sizeof(uint64_t))
-            return exchange_one_int64;
-        else
-            return exchange_int64s;
-    case 4:
-    case 12:
-        if (size == sizeof(uint32_t))
-            return exchange_one_int32;
-        else
-            return exchange_int32s;
-    case 2:
-    case 6:
-    case 10:
-    case 14:
-        if (size == sizeof(uint16_t))
-            return exchange_one_int16;
-        else
-            return exchange_int16s;
-    default:
-        if (size == 1)
-            return exchange_one_byte;
-        else
-            return exchange_bytes;
-    }
-}
-
-static void heapsortx(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
-{
-    uint8_t *basep = (uint8_t *)base;
-    size_t i, n, c, r;
-    exchange_f swap = exchange_func(base, size);
-
-    if (nmemb > 1) {
-        i = (nmemb / 2) * size;
-        n = nmemb * size;
-
-        while (i > 0) {
-            i -= size;
-            for (r = i; (c = r * 2 + size) < n; r = c) {
-                if (c < n - size && cmp(basep + c, basep + c + size, opaque) <= 0)
-                    c += size;
-                if (cmp(basep + r, basep + c, opaque) > 0)
-                    break;
-                swap(basep + r, basep + c, size);
-            }
-        }
-        for (i = n - size; i > 0; i -= size) {
-            swap(basep, basep + i, size);
-
-            for (r = 0; (c = r * 2 + size) < i; r = c) {
-                if (c < i - size && cmp(basep + c, basep + c + size, opaque) <= 0)
-                    c += size;
-                if (cmp(basep + r, basep + c, opaque) > 0)
-                    break;
-                swap(basep + r, basep + c, size);
-            }
-        }
-    }
-}
-
-static inline void *med3(void *a, void *b, void *c, cmp_f cmp, void *opaque)
-{
-    return cmp(a, b, opaque) < 0 ?
-        (cmp(b, c, opaque) < 0 ? b : (cmp(a, c, opaque) < 0 ? c : a )) :
-        (cmp(b, c, opaque) > 0 ? b : (cmp(a, c, opaque) < 0 ? a : c ));
-}
-
-/* pointer based version with local stack and insertion sort threshhold */
-void rqsort(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
-{
-    struct { uint8_t *base; size_t count; int depth; } stack[50], *sp = stack;
-    uint8_t *ptr, *pi, *pj, *plt, *pgt, *top, *m;
-    size_t m4, i, lt, gt, span, span2;
-    int c, depth;
-    exchange_f swap = exchange_func(base, size);
-    exchange_f swap_block = exchange_func(base, size | 128);
-
-    if (nmemb < 2 || size <= 0)
-        return;
-
-    sp->base = (uint8_t *)base;
-    sp->count = nmemb;
-    sp->depth = 0;
-    sp++;
-
-    while (sp > stack) {
-        sp--;
-        ptr = sp->base;
-        nmemb = sp->count;
-        depth = sp->depth;
-
-        while (nmemb > 6) {
-            if (++depth > 50) {
-                /* depth check to ensure worst case logarithmic time */
-                heapsortx(ptr, nmemb, size, cmp, opaque);
-                nmemb = 0;
-                break;
-            }
-            /* select median of 3 from 1/4, 1/2, 3/4 positions */
-            /* should use median of 5 or 9? */
-            m4 = (nmemb >> 2) * size;
-            m = med3(ptr + m4, ptr + 2 * m4, ptr + 3 * m4, cmp, opaque);
-            swap(ptr, m, size);  /* move the pivot to the start or the array */
-            i = lt = 1;
-            pi = plt = ptr + size;
-            gt = nmemb;
-            pj = pgt = top = ptr + nmemb * size;
-            for (;;) {
-                while (pi < pj && (c = cmp(ptr, pi, opaque)) >= 0) {
-                    if (c == 0) {
-                        swap(plt, pi, size);
-                        lt++;
-                        plt += size;
-                    }
-                    i++;
-                    pi += size;
-                }
-                while (pi < (pj -= size) && (c = cmp(ptr, pj, opaque)) <= 0) {
-                    if (c == 0) {
-                        gt--;
-                        pgt -= size;
-                        swap(pgt, pj, size);
-                    }
-                }
-                if (pi >= pj)
-                    break;
-                swap(pi, pj, size);
-                i++;
-                pi += size;
-            }
-            /* array has 4 parts:
-             * from 0 to lt excluded: elements identical to pivot
-             * from lt to pi excluded: elements smaller than pivot
-             * from pi to gt excluded: elements greater than pivot
-             * from gt to n excluded: elements identical to pivot
-             */
-            /* move elements identical to pivot in the middle of the array: */
-            /* swap values in ranges [0..lt[ and [i-lt..i[
-               swapping the smallest span between lt and i-lt is sufficient
-             */
-            span = plt - ptr;
-            span2 = pi - plt;
-            lt = i - lt;
-            if (span > span2)
-                span = span2;
-            swap_block(ptr, pi - span, span);
-            /* swap values in ranges [gt..top[ and [i..top-(top-gt)[
-               swapping the smallest span between top-gt and gt-i is sufficient
-             */
-            span = top - pgt;
-            span2 = pgt - pi;
-            pgt = top - span2;
-            gt = nmemb - (gt - i);
-            if (span > span2)
-                span = span2;
-            swap_block(pi, top - span, span);
-
-            /* now array has 3 parts:
-             * from 0 to lt excluded: elements smaller than pivot
-             * from lt to gt excluded: elements identical to pivot
-             * from gt to n excluded: elements greater than pivot
-             */
-            /* stack the larger segment and keep processing the smaller one
-               to minimize stack use for pathological distributions */
-            if (lt > nmemb - gt) {
-                sp->base = ptr;
-                sp->count = lt;
-                sp->depth = depth;
-                sp++;
-                ptr = pgt;
-                nmemb -= gt;
-            } else {
-                sp->base = pgt;
-                sp->count = nmemb - gt;
-                sp->depth = depth;
-                sp++;
-                nmemb = lt;
-            }
-        }
-        /* Use insertion sort for small fragments */
-        for (pi = ptr + size, top = ptr + nmemb * size; pi < top; pi += size) {
-            for (pj = pi; pj > ptr && cmp(pj - size, pj, opaque) > 0; pj -= size)
-                swap(pj, pj - size, size);
-        }
-    }
-}
-
-#endif

src/quickjs/cutils.h

@@ -1,341 +0,0 @@
-/*
- * C utilities
- *
- * Copyright (c) 2017 Fabrice Bellard
- * Copyright (c) 2018 Charlie Gordon
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#ifndef CUTILS_H
-#define CUTILS_H
-
-#include <stdlib.h>
-#include <string.h>
-#include <inttypes.h>
-
-#define likely(x)       __builtin_expect(!!(x), 1)
-#define unlikely(x)     __builtin_expect(!!(x), 0)
-#define force_inline inline __attribute__((always_inline))
-#define no_inline __attribute__((noinline))
-#define __maybe_unused __attribute__((unused))
-
-#define xglue(x, y) x ## y
-#define glue(x, y) xglue(x, y)
-#define stringify(s)    tostring(s)
-#define tostring(s)     #s
-
-#ifndef offsetof
-#define offsetof(type, field) ((size_t) &((type *)0)->field)
-#endif
-#ifndef countof
-#define countof(x) (sizeof(x) / sizeof((x)[0]))
-#endif
-#ifndef container_of
-/* return the pointer of type 'type *' containing 'ptr' as field 'member' */
-#define container_of(ptr, type, member) ((type *)((uint8_t *)(ptr) - offsetof(type, member)))
-#endif
-
-typedef int BOOL;
-
-#ifndef FALSE
-enum {
-    FALSE = 0,
-    TRUE = 1,
-};
-#endif
-
-void pstrcpy(char *buf, int buf_size, const char *str);
-char *pstrcat(char *buf, int buf_size, const char *s);
-int strstart(const char *str, const char *val, const char **ptr);
-int has_suffix(const char *str, const char *suffix);
-
-/* Prevent UB when n == 0 and (src == NULL or dest == NULL) */
-static inline void memcpy_no_ub(void *dest, const void *src, size_t n) {
-    if (n)
-        memcpy(dest, src, n);
-}
-
-static inline int max_int(int a, int b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline int min_int(int a, int b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-static inline uint32_t max_uint32(uint32_t a, uint32_t b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline uint32_t min_uint32(uint32_t a, uint32_t b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-static inline int64_t max_int64(int64_t a, int64_t b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline int64_t min_int64(int64_t a, int64_t b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int clz32(unsigned int a)
-{
-    return __builtin_clz(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int clz64(uint64_t a)
-{
-    return __builtin_clzll(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int ctz32(unsigned int a)
-{
-    return __builtin_ctz(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int ctz64(uint64_t a)
-{
-    return __builtin_ctzll(a);
-}
-
-struct __attribute__((packed)) packed_u64 {
-    uint64_t v;
-};
-
-struct __attribute__((packed)) packed_u32 {
-    uint32_t v;
-};
-
-struct __attribute__((packed)) packed_u16 {
-    uint16_t v;
-};
-
-static inline uint64_t get_u64(const uint8_t *tab)
-{
-    return ((const struct packed_u64 *)tab)->v;
-}
-
-static inline int64_t get_i64(const uint8_t *tab)
-{
-    return (int64_t)((const struct packed_u64 *)tab)->v;
-}
-
-static inline void put_u64(uint8_t *tab, uint64_t val)
-{
-    ((struct packed_u64 *)tab)->v = val;
-}
-
-static inline uint32_t get_u32(const uint8_t *tab)
-{
-    return ((const struct packed_u32 *)tab)->v;
-}
-
-static inline int32_t get_i32(const uint8_t *tab)
-{
-    return (int32_t)((const struct packed_u32 *)tab)->v;
-}
-
-static inline void put_u32(uint8_t *tab, uint32_t val)
-{
-    ((struct packed_u32 *)tab)->v = val;
-}
-
-static inline uint32_t get_u16(const uint8_t *tab)
-{
-    return ((const struct packed_u16 *)tab)->v;
-}
-
-static inline int32_t get_i16(const uint8_t *tab)
-{
-    return (int16_t)((const struct packed_u16 *)tab)->v;
-}
-
-static inline void put_u16(uint8_t *tab, uint16_t val)
-{
-    ((struct packed_u16 *)tab)->v = val;
-}
-
-static inline uint32_t get_u8(const uint8_t *tab)
-{
-    return *tab;
-}
-
-static inline int32_t get_i8(const uint8_t *tab)
-{
-    return (int8_t)*tab;
-}
-
-static inline void put_u8(uint8_t *tab, uint8_t val)
-{
-    *tab = val;
-}
-
-#ifndef bswap16
-static inline uint16_t bswap16(uint16_t x)
-{
-    return (x >> 8) | (x << 8);
-}
-#endif
-
-#ifndef bswap32
-static inline uint32_t bswap32(uint32_t v)
-{
-    return ((v & 0xff000000) >> 24) | ((v & 0x00ff0000) >>  8) |
-        ((v & 0x0000ff00) <<  8) | ((v & 0x000000ff) << 24);
-}
-#endif
-
-#ifndef bswap64
-static inline uint64_t bswap64(uint64_t v)
-{
-    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
-        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
-        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
-        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
-        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
-        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
-        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
-        ((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
-}
-#endif
-
-/* XXX: should take an extra argument to pass slack information to the caller */
-typedef void *DynBufReallocFunc(void *opaque, void *ptr, size_t size);
-
-typedef struct DynBuf {
-    uint8_t *buf;
-    size_t size;
-    size_t allocated_size;
-    BOOL error; /* true if a memory allocation error occurred */
-    DynBufReallocFunc *realloc_func;
-    void *opaque; /* for realloc_func */
-} DynBuf;
-
-void dbuf_init(DynBuf *s);
-void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func);
-int dbuf_realloc(DynBuf *s, size_t new_size);
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len);
-int dbuf_put(DynBuf *s, const uint8_t *data, size_t len);
-int dbuf_put_self(DynBuf *s, size_t offset, size_t len);
-int dbuf_putc(DynBuf *s, uint8_t c);
-int dbuf_putstr(DynBuf *s, const char *str);
-static inline int dbuf_put_u16(DynBuf *s, uint16_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 2);
-}
-static inline int dbuf_put_u32(DynBuf *s, uint32_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 4);
-}
-static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 8);
-}
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...);
-void dbuf_free(DynBuf *s);
-static inline BOOL dbuf_error(DynBuf *s) {
-    return s->error;
-}
-static inline void dbuf_set_error(DynBuf *s)
-{
-    s->error = TRUE;
-}
-
-#define UTF8_CHAR_LEN_MAX 6
-
-int unicode_to_utf8(uint8_t *buf, unsigned int c);
-int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp);
-
-static inline BOOL is_surrogate(uint32_t c)
-{
-    return (c >> 11) == (0xD800 >> 11); // 0xD800-0xDFFF
-}
-
-static inline BOOL is_hi_surrogate(uint32_t c)
-{
-    return (c >> 10) == (0xD800 >> 10); // 0xD800-0xDBFF
-}
-
-static inline BOOL is_lo_surrogate(uint32_t c)
-{
-    return (c >> 10) == (0xDC00 >> 10); // 0xDC00-0xDFFF
-}
-
-static inline uint32_t get_hi_surrogate(uint32_t c)
-{
-    return (c >> 10) - (0x10000 >> 10) + 0xD800;
-}
-
-static inline uint32_t get_lo_surrogate(uint32_t c)
-{
-    return (c & 0x3FF) | 0xDC00;
-}
-
-static inline uint32_t from_surrogate(uint32_t hi, uint32_t lo)
-{
-    return 0x10000 + 0x400 * (hi - 0xD800) + (lo - 0xDC00);
-}
-
-static inline int from_hex(int c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    else if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    else if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    else
-        return -1;
-}
-
-void rqsort(void *base, size_t nmemb, size_t size,
-            int (*cmp)(const void *, const void *, void *),
-            void *arg);
-
-#endif  /* CUTILS_H */

src/quickjs/debug.c

@@ -1,483 +0,0 @@
-#define _IN_DEBUG_C 1
-#include "debug.h"
-#include <quickjs.h>
-#include <list.h>
-#include <cutils.h>
-#include <assert.h>
-#include "defines.h"
-#include <string.h>
-#include <stdlib.h>
-
-/**
- * \addtogroup debug
- * @{
- */
-struct alloc_block {
-  struct list_head link;
-  const char* file;
-  int line;
-  size_t size;
-};
-
-#define ALLOC_BLOCK_SIZE sizeof(struct alloc_block)
-#define ALLOC_BLOCK(p) (((struct alloc_block*)(p)) - 1)
-#define ALLOC_PTR struct alloc_block*
-
-#undef malloc
-#undef calloc
-#undef realloc
-#undef strdup
-#undef free
-#undef js_malloc
-#undef js_mallocz
-#undef js_realloc
-#undef js_strdup
-#undef js_strndup
-#undef js_free
-#undef js_malloc_usable_size
-#undef js_malloc_rt
-#undef js_mallocz_rt
-#undef js_realloc_rt
-#undef js_free_rt
-#undef js_malloc_usable_size_rt
-
-thread_local struct list_head alloc_block_list = {0, 0};
-
-static inline void
-add_to_list(struct list_head* el, struct list_head* head) {
-  if(alloc_block_list.prev == 0 && alloc_block_list.next == 0)
-    init_list_head(&alloc_block_list);
-
-  list_add_tail(el, head);
-}
-
-int64_t
-check_pointer(void* p) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-  struct list_head* link;
-  int64_t ret = 0;
-  list_for_each(link, &alloc_block_list) {
-    if(link == &ptr->link)
-      return ret;
-    ret++;
-  }
-  // assert(0);
-  return -1;
-}
-
-void*
-debug_malloc(size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = malloc(n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_calloc(size_t m, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  m *= n;
-  n = 1;
-
-  if((ptr = calloc(m + ALLOC_BLOCK_SIZE, 1))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_realloc(void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-
-    if(n == 0) {
-      free(ptr);
-      return 0;
-    }
-
-    ptr = realloc(ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = malloc(n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_strdup(const char* s, const char* file, int line) {
-  ALLOC_PTR ptr;
-  size_t len = strlen(s);
-
-  if((ptr = malloc(len + 1 + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(&ptr[1], s, len + 1);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void
-debug_free(void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  free(ptr);
-}
-
-void*
-debug_js_malloc(JSContext* ctx, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_mallocz(JSContext* ctx, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_mallocz(ctx, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc(JSContext* ctx, void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-
-    if(n == 0) {
-      js_free(ctx, ptr);
-      return 0;
-    }
-
-    ptr = js_realloc(ctx, ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc2(JSContext* ctx, void* p, size_t size, size_t* pslack, const char* file, int line) {
-  void* ptr;
-
-  if((ptr = debug_js_realloc(ctx, p, size, file, line))) {
-    if(pslack) {
-      size_t new_size = debug_js_malloc_usable_size(ctx, ptr, file, line);
-      *pslack = (new_size > size) ? new_size - size : 0;
-    }
-  }
-  return ptr;
-}
-
-void*
-debug_js_strdup(JSContext* ctx, const char* s, const char* file, int line) {
-  ALLOC_PTR ptr;
-  size_t len = strlen(s);
-
-  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
-    char* p = (char*)&ptr[1];
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(p, s, len + 1);
-    return p;
-  }
-  return 0;
-}
-
-void*
-debug_js_strndup(JSContext* ctx, const char* s, size_t len, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
-    char* p = (char*)&ptr[1];
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(p, s, len);
-    p[len] = '\0';
-
-    return p;
-  }
-  return 0;
-}
-
-size_t
-debug_js_malloc_usable_size(JSContext* ctx, const void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  return js_malloc_usable_size(ctx, ptr) - ALLOC_BLOCK_SIZE;
-}
-
-void
-debug_js_free(JSContext* ctx, void* p, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  check_pointer(p);
-  ptr = ALLOC_BLOCK(p);
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  js_free(ctx, ptr);
-}
-
-void*
-debug_js_malloc_rt(JSRuntime* rt, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_mallocz_rt(JSRuntime* rt, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_mallocz_rt(rt, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc_rt(JSRuntime* rt, void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-    if(n == 0) {
-      js_free_rt(rt, ptr);
-      return 0;
-    }
-    ptr = js_realloc_rt(rt, ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-size_t
-debug_js_malloc_usable_size_rt(JSRuntime* rt, const void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  return js_malloc_usable_size_rt(rt, ptr) - ALLOC_BLOCK_SIZE;
-}
-
-void
-debug_js_free_rt(JSRuntime* rt, void* p, const char* file, int line) {
-  ALLOC_PTR ptr;
-  check_pointer(p);
-
-  ptr = ALLOC_BLOCK(p);
-
-  // printf("debug_js_free_rt %p\n", p);
-
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  js_free_rt(rt, ptr);
-}
-
-#undef malloc
-#undef calloc
-#undef realloc
-#undef strdup
-#undef free
-#undef js_malloc
-#undef js_mallocz
-#undef js_realloc
-#undef js_strdup
-#undef js_strndup
-#undef js_malloc_usable_size
-#undef js_free
-#undef js_malloc_rt
-#undef js_mallocz_rt
-#undef js_realloc_rt
-#undef js_malloc_usable_size_rt
-#undef js_free_rt
-
-void*
-orig_malloc(size_t size) {
-  return malloc(size);
-}
-
-void*
-orig_calloc(size_t nelem, size_t elemsz) {
-  return calloc(nelem, elemsz);
-}
-
-void*
-orig_realloc(void* ptr, size_t size) {
-  return realloc(ptr, size);
-}
-
-void*
-orig_strdup(const char* str) {
-  return strdup(str);
-}
-
-void
-orig_free(void* ptr) {
-  free(ptr);
-}
-
-void*
-orig_js_malloc(JSContext* ctx, size_t size) {
-  return js_malloc(ctx, size);
-}
-
-void*
-orig_js_mallocz(JSContext* ctx, size_t size) {
-  return js_mallocz(ctx, size);
-}
-
-void*
-orig_js_realloc(JSContext* ctx, void* p, size_t size) {
-  return js_realloc(ctx, p, size);
-}
-
-void*
-orig_js_strdup(JSContext* ctx, const char* str) {
-  return js_strdup(ctx, str);
-}
-
-void*
-orig_js_strndup(JSContext* ctx, const char* str, size_t size) {
-  return js_strndup(ctx, str, size);
-}
-
-size_t
-orig_js_malloc_usable_size(JSContext* ctx, const void* p) {
-  return js_malloc_usable_size(ctx, p);
-}
-
-void
-orig_js_free(JSContext* ctx, void* p) {
-  return js_free(ctx, p);
-}
-
-void*
-orig_js_malloc_rt(JSRuntime* rt, size_t size) {
-  return js_malloc_rt(rt, size);
-}
-
-void*
-orig_js_mallocz_rt(JSRuntime* rt, size_t size) {
-  return js_mallocz_rt(rt, size);
-}
-
-void*
-orig_js_realloc_rt(JSRuntime* rt, void* p, size_t size) {
-  return js_realloc_rt(rt, p, size);
-}
-
-size_t
-orig_js_malloc_usable_size_rt(JSRuntime* rt, const void* p) {
-  return js_malloc_usable_size_rt(rt, p);
-}
-
-void
-orig_js_free_rt(JSRuntime* rt, void* p) {
-  return js_free_rt(rt, p);
-}
-
-/**
- * @}
- */

src/quickjs/debug.h

@@ -1,165 +0,0 @@
-#ifndef DEBUG_H
-#define DEBUG_H
-
-#include <quickjs.h>
-#include <cutils.h>
-#include "defines.h"
-
-#ifndef QUICKJS_H
-#error "quickjs.h not included"
-#endif
-
-/**
- * \defgroup debug debug: Debugging helpers
- * @{
- */
-
-extern thread_local struct list_head alloc_block_list;
-
-int64_t check_pointer(void*);
-void* debug_malloc(size_t, const char*, int);
-void* debug_calloc(size_t, size_t, const char*, int line);
-void* debug_realloc(void*, size_t, const char*, int line);
-void* debug_strdup(const char*, const char*, int);
-void debug_free(void*, const char*, int);
-void* debug_js_malloc(JSContext*, size_t, const char*, int line);
-void* debug_js_mallocz(JSContext*, size_t, const char*, int line);
-void* debug_js_realloc(JSContext*, void*, size_t, const char* file, int line);
-void* debug_js_realloc2(JSContext*, void*, size_t, size_t* pslack, const char* file, int line);
-void* debug_js_strdup(JSContext*, const char*, const char*, int line);
-void* debug_js_strndup(JSContext*, const char*, size_t, const char* file, int line);
-size_t debug_js_malloc_usable_size(JSContext*, const void*, const char*, int line);
-void debug_js_free(JSContext*, void*, const char*, int line);
-void* debug_js_malloc_rt(JSRuntime*, size_t, const char*, int line);
-void* debug_js_mallocz_rt(JSRuntime*, size_t, const char*, int line);
-void* debug_js_realloc_rt(JSRuntime*, void*, size_t, const char* file, int line);
-size_t debug_js_malloc_usable_size_rt(JSRuntime*, const void*, const char*, int line);
-void debug_js_free_rt(JSRuntime*, void*, const char*, int line);
-
-#if !defined(_IN_DEBUG_C)
-
-#if defined(DEBUG_ALLOC)
-#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
-#define calloc(nelem, size) debug_calloc(nelem, size, __FILE__, __LINE__)
-#define realloc(ptr, size) debug_realloc(ptr, size, __FILE__, __LINE__)
-#define strdup(str) debug_strdup(str, __FILE__, __LINE__)
-#define free(ptr) debug_free(ptr, __FILE__, __LINE__)
-#define js_malloc(ctx, size) debug_js_malloc(ctx, size, __FILE__, __LINE__)
-#define js_mallocz(ctx, size) debug_js_mallocz(ctx, size, __FILE__, __LINE__)
-#define js_realloc(ctx, ptr, size) debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__)
-#define js_strdup(ctx, str) debug_js_strdup(ctx, str, __FILE__, __LINE__)
-#define js_strndup(ctx, str, len) debug_js_strndup(ctx, str, len, __FILE__, __LINE__)
-#define js_free(ctx, ptr) debug_js_free(ctx, ptr, __FILE__, __LINE__)
-#define js_malloc_usable_size(ctx, ptr) debug_js_malloc_usable_size(ctx, ptr, __FILE__, __LINE__)
-#define js_malloc_rt(rt, size) debug_js_malloc_rt(rt, size, __FILE__, __LINE__)
-#define js_mallocz_rt(rt, size) debug_js_mallocz_rt(rt, size, __FILE__, __LINE__)
-#define js_realloc_rt(rt, ptr, size) debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__)
-#define js_malloc_usable_size_rt(rt, ptr) debug_js_malloc_usable_size_rt(rt, ptr, __FILE__, __LINE__)
-#define js_free_rt(rt, ptr) debug_js_free_rt(rt, ptr, __FILE__, __LINE__)
-#endif
-
-#ifdef DEBUG_ALLOC
-#define realloc_helper(name) \
-  void* name(void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_malloc(size, __FILE__, __LINE__); \
-    if(size == 0) \
-      return debug_free(ptr, __FILE__, __LINE__); \
-    return debug_realloc(ptr, size, __FILE__, __LINE__); \
-  }
-#define realloc2_helper(name) \
-  void* name(void* opaque, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_malloc(size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_free(ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_realloc(ptr, size, __FILE__, __LINE__); \
-  }
-#define js_realloc_helper(name) \
-  void* name(JSContext* ctx, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_js_malloc(ctx, size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_js_free(ctx, ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__); \
-  }
-#define js_realloc_rt_helper(name) \
-  void* name(JSRuntime* rt, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_js_malloc_rt(rt, size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_js_free_rt(rt, ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__); \
-  }
-#else
-#define realloc_helper(name) \
-  void* name(void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return malloc(size); \
-    if(size == 0) { \
-      free(ptr); \
-      return 0; \
-    } \
-    return realloc(ptr, size); \
-  }
-#define realloc2_helper(name) \
-  void* name(void* opaque, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return malloc(size); \
-    if(size == 0) { \
-      free(ptr); \
-      return 0; \
-    } \
-    return realloc(ptr, size); \
-  }
-#define js_realloc_helper(name) \
-  void* name(JSContext* ctx, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return orig_js_malloc(ctx, size); \
-    if(size == 0) { \
-      orig_js_free(ctx, ptr); \
-      return 0; \
-    } \
-    return orig_js_realloc(ctx, ptr, size); \
-  }
-#define js_realloc_rt_helper(name) \
-  void* name(JSRuntime* rt, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return orig_js_malloc_rt(rt, size); \
-    if(size == 0) { \
-      orig_js_free_rt(rt, ptr); \
-      return 0; \
-    } \
-    return orig_js_realloc_rt(rt, ptr, size); \
-  }
-#endif
-#endif
-
-void* orig_malloc(size_t);
-void* orig_calloc(size_t, size_t);
-void* orig_realloc(void*, size_t);
-void* orig_strdup(const char*);
-void orig_free(void*);
-void* orig_js_malloc(JSContext*, size_t);
-void* orig_js_mallocz(JSContext*, size_t);
-void* orig_js_realloc(JSContext*, void*, size_t);
-void* orig_js_strdup(JSContext*, const char*);
-void* orig_js_strndup(JSContext*, const char*, size_t);
-size_t orig_js_malloc_usable_size(JSContext*, const void*);
-void orig_js_free(JSContext*, void*);
-void* orig_js_malloc_rt(JSRuntime*, size_t);
-void* orig_js_mallocz_rt(JSRuntime*, size_t);
-void* orig_js_realloc_rt(JSRuntime*, void*, size_t);
-size_t orig_js_malloc_usable_size_rt(JSRuntime*, const void*);
-void orig_js_free_rt(JSRuntime*, void*);
-
-/**
- * @}
- */
-#endif /* defined(DEBUG_H) */

src/quickjs/defines.h

@@ -1,181 +0,0 @@
-#ifndef DEFINES_H
-#define DEFINES_H
-
-/**
- * \defgroup defines defines: Preprocessor definitions
- * @{
- */
-
-#ifdef _WIN32
-#include <io.h>
-#define FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
-#define SOCKET_TO_FD(fh) (_open_osfhandle((intptr_t)(fh), O_RDWR | O_BINARY))
-#else
-#define FD_TO_SOCKET(fd) (fd)
-#define SOCKET_TO_FD(fh) (fh)
-#endif
-
-#ifndef offsetof
-#define offsetof(type, field) ((size_t) & ((type*)0)->field)
-#endif
-
-#ifndef inrange
-#define inrange(value, min, max) ((value) >= (min) && (value) <= (max))
-#endif
-
-#define trim_dotslash(str) (!strncmp((str), "./", 2) ? (str) + 2 : (str))
-
-#ifndef thread_local
-#ifdef _Thread_local
-#define thread_local _Thread_local
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
-#define thread_local __thread
-#elif defined(_WIN32)
-#define thread_local __declspec(thread)
-#else
-#error No TLS implementation found.
-#endif
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#define PACK __attribute__((packed))
-#define ENDPACK
-#else
-#define PACK #pragma pack(push, 1)
-#define ENDPACK #pragma pack(pop)
-#endif
-
-#define JS_CGETSET_ENUMERABLE_DEF(prop_name, fgetter, fsetter, magic_num) \
-  { \
-    .name = prop_name, .prop_flags = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
-      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
-    } \
-  }
-
-#define JS_CGETSET_MAGIC_FLAGS_DEF(prop_name, fgetter, fsetter, magic_num, flags) \
-  { \
-    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
-      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
-    } \
-  }
-
-#define JS_CFUNC_DEF_FLAGS(prop_name, length, func1, flags) \
-  { \
-    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CFUNC, .magic = 0, .u = {.func = {length, JS_CFUNC_generic, {.generic = func1}} } \
-  }
-
-#define JS_CONSTANT_FLAGS(name, flags) JS_PROP_INT32_DEF(#name, name, (flags))
-#define JS_CONSTANT(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)
-#define JS_CONSTANT_NONENUMERABLE(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE)
-
-#ifdef JS_SHARED_LIBRARY
-#if defined(_WIN32) || defined(__MINGW32__)
-#define VISIBLE __declspec(dllexport)
-#define HIDDEN
-#else
-#define VISIBLE __attribute__((visibility("default")))
-#define HIDDEN __attribute__((visibility("hidden")))
-#endif
-#else
-#define VISIBLE
-#define HIDDEN
-#endif
-
-#ifndef MAX_NUM
-#define MAX_NUM(a, b) ((a) > (b) ? (a) : (b))
-#endif
-#ifndef MIN_NUM
-#define MIN_NUM(a, b) ((a) < (b) ? (a) : (b))
-#endif
-#ifndef ABS_NUM
-#define ABS_NUM(n) ((n) < 0 ? -(n) : (n))
-#endif
-#ifndef MOD_NUM
-#define MOD_NUM(n, divisor) ((((n) % (divisor)) + (divisor)) % (divisor))
-#endif
-#ifndef SIGN_NUM
-#define SIGN_NUM(n) ((n) < 0)
-#endif
-
-#define COLOR_BLACK "\x1b[0;30m"
-#define COLOR_RED "\x1b[0;31m"
-#define COLOR_GREEN "\x1b[0;32m"
-#define COLOR_BROWN "\x1b[0;33m"
-#define COLOR_BLUE "\x1b[0;34m"
-#define COLOR_PURPLE "\x1b[0;35m"
-#define COLOR_MARINE "\x1b[0;36m"
-#define COLOR_LIGHTGRAY "\x1b[0;37m"
-#define COLOR_GRAY "\x1b[1;30m"
-#define COLOR_NONE "\x1b[0m"
-
-#define COLOR_LIGHTRED "\x1b[1;31m"
-
-#define COLOR_LIGHTGREEN "\x1b[1;32m"
-#define COLOR_YELLOW "\x1b[1;33m"
-#define COLOR_LIGHTBLUE "\x1b[1;34m"
-#define COLOR_MAGENTA "\x1b[1;35m"
-#define COLOR_CYAN "\x1b[1;36m"
-#define COLOR_WHITE "\x1b[1;37m"
-
-#define BGCOLOR_RED "\x1b[48;5;124m"
-#define BGCOLOR_BLUE "\x1b[48;5;20m"
-#define BGCOLOR_YELLOW "\x1b[48;5;214m"
-#define BGCOLOR_GREEN "\x1b[48;5;28m"
-#define BGCOLOR_PINK "\x1b[48;5;165m"
-
-#define JS_VALUE_FREE(ctx, value) \
-  do { \
-    JS_FreeValue((ctx), (value)); \
-    (value) = JS_UNDEFINED; \
-  } while(0);
-#define JS_VALUE_FREE_RT(ctx, value) \
-  do { \
-    JS_FreeValueRT((ctx), (value)); \
-    (value) = JS_UNDEFINED; \
-  } while(0);
-
-#if 0
-#define js_object_tmpmark_set(value) \
-  do { \
-    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] |= 0x40; \
-  } while(0);
-#define js_object_tmpmark_clear(value) \
-  do { \
-    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] &= ~0x40; \
-  } while(0);
-#define js_object_tmpmark_isset(value) (((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] & 0x40)
-#else
-#define js_object_tmpmark_set(value) \
-  do { \
-    JS_VALUE_GET_OBJ((value))->tmp_mark |= 0x40; \
-  } while(0);
-#define js_object_tmpmark_clear(value) \
-  do { \
-    JS_VALUE_GET_OBJ((value))->tmp_mark &= ~0x40; \
-  } while(0);
-#define js_object_tmpmark_isset(value) (JS_VALUE_GET_OBJ((value))->tmp_mark & 0x40)
-#endif
-
-#define js_runtime_exception_set(rt, value) \
-  do { \
-    *(JSValue*)((uint8_t*)(rt) + 216) = value; \
-  } while(0);
-#define js_runtime_exception_get(rt) (*(JSValue*)((uint8_t*)(rt) + 216))
-#define js_runtime_exception_clear(rt) \
-  do { \
-    if(!JS_IsNull(js_runtime_exception_get(rt))) \
-      JS_FreeValueRT((rt), js_runtime_exception_get(rt)); \
-    js_runtime_exception_set(rt, JS_NULL); \
-  } while(0)
-
-#define JS_ATOM_TAG_INT (1U << 31)
-#define JS_ATOM_MAX_INT (JS_ATOM_TAG_INT - 1)
-
-#define JS_ATOM_ISINT(i) ((JSAtom)((i)&JS_ATOM_TAG_INT))
-#define JS_ATOM_FROMINT(i) ((JSAtom)((i)&JS_ATOM_MAX_INT) | JS_ATOM_TAG_INT)
-#define JS_ATOM_TOINT(i) (unsigned int)(((JSAtom)(i) & (~(JS_ATOM_TAG_INT))))
-
-/**
- * @}
- */
-#endif /* defined(DEFINES_H) */

src/quickjs/hello.c

@@ -1,45 +0,0 @@
-/* File generated automatically by the QuickJS compiler. */
-
-#include "quickjs-libc.h"
-
-const uint32_t qjsc_hello_size = 87;
-
-const uint8_t qjsc_hello[87] = {
- 0x43, 0x04, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x6f,
- 0x6c, 0x65, 0x06, 0x6c, 0x6f, 0x67, 0x16, 0x48,
- 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72,
- 0x6c, 0x64, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70,
- 0x6c, 0x65, 0x73, 0x2f, 0x68, 0x65, 0x6c, 0x6c,
- 0x6f, 0x2e, 0x6a, 0x73, 0x0c, 0x00, 0x06, 0x00,
- 0xa2, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00,
- 0x14, 0x01, 0xa4, 0x01, 0x00, 0x00, 0x00, 0x38,
- 0xe3, 0x00, 0x00, 0x00, 0x42, 0xe4, 0x00, 0x00,
- 0x00, 0x04, 0xe5, 0x00, 0x00, 0x00, 0x24, 0x01,
- 0x00, 0xcf, 0x28, 0xcc, 0x03, 0x01, 0x00,
-};
-
-static JSContext *JS_NewCustomContext(JSRuntime *rt)
-{
-  JSContext *ctx = JS_NewContextRaw(rt);
-  if (!ctx)
-    return NULL;
-  JS_AddIntrinsicBaseObjects(ctx);
-  return ctx;
-}
-
-int main(int argc, char **argv)
-{
-  JSRuntime *rt;
-  JSContext *ctx;
-  rt = JS_NewRuntime();
-  js_std_set_worker_new_context_func(JS_NewCustomContext);
-  js_std_init_handlers(rt);
-  ctx = JS_NewCustomContext(rt);
-  js_std_add_helpers(ctx, argc, argv);
-  js_std_eval_binary(ctx, qjsc_hello, qjsc_hello_size, 0);
-  js_std_loop(ctx);
-  js_std_free_handlers(rt);
-  JS_FreeContext(ctx);
-  JS_FreeRuntime(rt);
-  return 0;
-}

src/quickjs/iso_8859_1.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_1_H
-#define TUTF8E_ISO_8859_1_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_1_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_1_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_1_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_1_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_10.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_10_H
-#define TUTF8E_ISO_8859_10_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_10_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_10_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_10_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_10_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_11.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_11_H
-#define TUTF8E_ISO_8859_11_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_11_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_11_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_11_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_11_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_13.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_13_H
-#define TUTF8E_ISO_8859_13_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_13_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_13_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_13_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_13_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_14.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_14_H
-#define TUTF8E_ISO_8859_14_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_14_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_14_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_14, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_14_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_14_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_15.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_15_H
-#define TUTF8E_ISO_8859_15_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_15_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_15_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_15, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_15_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_15_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_16.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_16_H
-#define TUTF8E_ISO_8859_16_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_16_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_16_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_16, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_16_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_16_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_2.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_2_H
-#define TUTF8E_ISO_8859_2_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_2_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_2_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_2, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_2_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_2_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_3.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_3_H
-#define TUTF8E_ISO_8859_3_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_3_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_3_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_3, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_3_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_3_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_4.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_4_H
-#define TUTF8E_ISO_8859_4_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_4_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_4_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_4, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_4_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_4_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_5.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_5_H
-#define TUTF8E_ISO_8859_5_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_5_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_5_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_5, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_5_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_5_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_6.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_6_H
-#define TUTF8E_ISO_8859_6_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_6_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_6_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_6, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_6_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_6_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_7.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_7_H
-#define TUTF8E_ISO_8859_7_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_7_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_7_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_7_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_7_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_8.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_8_H
-#define TUTF8E_ISO_8859_8_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_8_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_8_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_8, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_8_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_8_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_9.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_9_H
-#define TUTF8E_ISO_8859_9_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_9_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_9_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_9, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_9_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_9_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output, output_length);
-}
-
-#endif