Update pom.xml - Deps

Corrections for NTP slipage at start up

.github/workflows/pr-testing.yml

@@ -1,27 +1,31 @@
 name: PR testing
 
 on:
-  pull_request:
+  push:
     branches: [ master ]
 
 jobs:
   mavenTesting:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Cache local Maven repository
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.m2/repository
         key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
         restore-keys: |
           ${{ runner.os }}-maven-
     - name: Set up the Java JDK
-      uses: actions/setup-java@v2
+      uses: actions/setup-java@v3
       with:
         java-version: '11'
         distribution: 'adopt'
 
+    - name: Load custom deps
+      run: |
+        mvn install -DskipTests=true --file pom.xml
+
     - name: Run all tests
       run: |
         mvn -B clean test -DskipTests=false --file pom.xml

.gitignore

@@ -14,7 +14,6 @@
 /.mvn.classpath
 /notes*
 /settings.json
-/testnet*
 /settings*.json
 /testchain*.json
 /run-testnet*.sh

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.compile.nullAnalysis.mode": "automatic"
+}

AutoUpdates.md

@@ -8,7 +8,7 @@
 * Build auto-update download: `tools/build-auto-update.sh` - uploads auto-update file into new git branch
 * Restart local node
 * Publish auto-update transaction using *private key* for **non-admin** member of "dev" group:
-	`tools/publish-auto-update.sh non-admin-dev-member-private-key-in-base58`
+	`tools/publish-auto-update.pl non-admin-dev-member-private-key-in-base58`
 * Wait for auto-update `ARBITRARY` transaction to be confirmed into a block
 * Have "dev" group admins 'approve' auto-update using `tools/approve-auto-update.sh`
 	This tool will prompt for *private key* of **admin** of "dev" group

Q-Apps.md

@@ -0,0 +1,919 @@
+# Qortal Project - Q-Apps Documentation
+
+## Introduction
+
+Q-Apps are static web apps written in javascript, HTML, CSS, and other static assets. The key difference between a Q-App and a fully static site is its ability to interact with both the logged-in user and on-chain data. This is achieved using the API described in this document.
+
+
+# Section 0: Basic QDN concepts
+
+## Introduction to QDN resources
+Each published item on QDN (Qortal Data Network) is referred to as a "resource". A resource could contain anything from a few characters of text, to a multi-layered directory structure containing thousands of files.
+
+Resources are stored on-chain, however the data payload is generally stored off-chain, and verified using an on-chain SHA-256 hash.
+
+To publish a resource, a user must first register a name, and then include that name when publishing the data. Accounts without a registered name are unable to publish to QDN from a Q-App at this time.
+
+Owning the name grants update privileges to the data. If that name is later sold or transferred, the permission to update that resource is moved to the new owner.
+
+
+## Name, service & identifier
+
+Each QDN resource has 3 important fields:
+- `name` - the registered name of the account that is publishing the data (which will hold update/edit privileges going forwards).<br /><br />
+- `service` - the type of content (e.g. IMAGE or JSON). Different services have different validation rules. See [list of available services](#services).<br /><br />
+- `identifier` - an optional string to allow more than one resource to exist for a given name/service combination. For example, the name `QortalDemo` may wish to publish multiple images. This can be achieved by using a different identifier string for each. The identifier is only unique to the name in question, and so it doesn't matter if another name is using the same service and identifier string.
+
+
+## Shared identifiers
+
+Since an identifier can be used by multiple names, this can be used to the advantage of Q-App developers as it allows for data to be stored in a deterministic location.
+
+An example of this is the user's avatar. This will always be published with service `THUMBNAIL` and identifier `qortal_avatar`, along with the user's name. So, an app can display the avatar of a user just by specifying their name when requesting the data. The same applies when publishing data.
+
+
+## "Default" resources
+
+A "default" resource refers to one without an identifier. For example, when a website is published via the UI, it will use the user's name and the service `WEBSITE`. These do not have an identifier, and are therefore the "default" website for this name. When requesting or publishing data without an identifier, apps can either omit the `identifier` key entirely, or include `"identifier": "default"` to indicate that the resource(s) being queried or published do not have an identifier.
+
+
+<a name="services"></a>
+## Available service types
+
+Here is a list of currently available services that can be used in Q-Apps:
+
+### Public services ###
+The services below are intended to be used for publicly accessible data.
+
+IMAGE,
+THUMBNAIL,
+VIDEO,
+AUDIO,
+PODCAST,
+VOICE,
+ARBITRARY_DATA,
+JSON,
+DOCUMENT,
+LIST,
+PLAYLIST,
+METADATA,
+BLOG,
+BLOG_POST,
+BLOG_COMMENT,
+GIF_REPOSITORY,
+ATTACHMENT,
+FILE,
+FILES,
+CHAIN_DATA,
+STORE,
+PRODUCT,
+OFFER,
+COUPON,
+CODE,
+PLUGIN,
+EXTENSION,
+GAME,
+ITEM,
+NFT,
+DATABASE,
+SNAPSHOT,
+COMMENT,
+CHAIN_COMMENT,
+WEBSITE,
+APP,
+QCHAT_ATTACHMENT,
+QCHAT_IMAGE,
+QCHAT_AUDIO,
+QCHAT_VOICE
+
+### Private services ###
+For the services below, data is encrypted for a single recipient, and can only be decrypted using the private key of the recipient's wallet.
+
+QCHAT_ATTACHMENT_PRIVATE,
+ATTACHMENT_PRIVATE,
+FILE_PRIVATE,
+IMAGE_PRIVATE,
+VIDEO_PRIVATE,
+AUDIO_PRIVATE,
+VOICE_PRIVATE,
+DOCUMENT_PRIVATE,
+MAIL_PRIVATE,
+MESSAGE_PRIVATE
+
+
+## Single vs multi-file resources
+
+Some resources, such as those published with the `IMAGE` or `JSON` service, consist of a single file or piece of data (the image or the JSON string). This is the most common type of QDN resource, especially in the context of Q-Apps. These can be published by supplying a base64-encoded string containing the data.
+
+Other resources, such as those published with the `WEBSITE`, `APP`, or `GIF_REPOSITORY` service, can contain multiple files and directories. Publishing these kinds of files is not yet available for Q-Apps, however it is possible to retrieve multi-file resources that are already published. When retrieving this data (via FETCH_QDN_RESOURCE), a `filepath` must be included to indicate the file that you would like to retrieve. There is no need to specify a filepath for single file resources, as these will automatically return the contents of the single file.
+
+
+## App-specific data
+
+Some apps may want to make all QDN data for a particular service available. However, others may prefer to only deal with data that has been published by their app (if a specific format/schema is being used for instance).
+
+Identifiers can be used to allow app developers to locate data that has been published by their app. The recommended approach for this is to use the app name as a prefix on all identifiers when publishing data.
+
+For instance, an app called `MyApp` could allow users to publish JSON data. The app could choose to prefix all identifiers with the string `myapp_`, and then use a random string for each published resource (resulting in identifiers such as `myapp_qR5ndZ8v`). Then, to locate data that has potentially been published by users of MyApp, it can later search the QDN database for items with `"service": "JSON"` and `"identifier": "myapp_"`. The SEARCH_QDN_RESOURCES action has a `prefix` option in order to match identifiers beginning with the supplied string.
+
+Note that QDN is a permissionless system, and therefore it's not possible to verify that a resource was actually published by the app. It is recommended that apps validate the contents of the resource to ensure it is formatted correctly, instead of making assumptions.
+
+
+## Updating a resource
+
+To update a resource, it can be overwritten by publishing with the same `name`, `service`, and `identifier` combination. Note that the authenticated account must currently own the name in order to publish an update.
+
+
+## Routing
+
+If a non-existent `filepath` is accessed, the default behaviour of QDN is to return a `404: File not found` error. This includes anything published using the `WEBSITE` service.
+
+However, routing is handled differently for anything published using the `APP` service. 
+
+For apps, QDN automatically sends all unhandled requests to the index file (generally index.html). This allows the app to use custom routing, as it is able to listen on any path. If a file exists at a path, the file itself will be served, and so the request won't be sent to the index file.
+
+It's recommended that all apps return a 404 page if a request isn't able to be routed.
+
+
+# Section 1: Simple links and image loading via HTML
+
+## Section 1a: Linking to other QDN websites / resources
+
+The `qortal://` protocol can be used to access QDN data from within Qortal websites and apps. The basic format is as follows:
+```
+<a href="qortal://{service}/{name}/{identifier}/{path}">link text</a>
+```
+
+However, the system will support the omission of the `identifier` and/or `path` components to allow for simpler URL formats.
+
+A simple link to another website can be achieved with this HTML code:
+```
+<a href="qortal://WEBSITE/QortalDemo">link text</a>
+```
+
+To link to a specific page of another website:
+```
+<a href="qortal://WEBSITE/QortalDemo/minting-leveling/index.html">link text</a>
+```
+
+To link to a standalone resource, such as an avatar
+```
+<a href="qortal://THUMBNAIL/QortalDemo/qortal_avatar">avatar</a>
+```
+
+For cases where you would prefer to explicitly include an identifier (to remove ambiguity) you can use the keyword `default` to access a resource that doesn't have an identifier. For instance:
+```
+<a href="qortal://WEBSITE/QortalDemo/default">link to root of website</a>
+<a href="qortal://WEBSITE/QortalDemo/default/minting-leveling/index.html">link to subpage of website</a>
+```
+
+
+## Section 1b: Linking to other QDN images
+
+The same applies for images, such as displaying an avatar:
+```
+<img src="qortal://THUMBNAIL/QortalDemo/qortal_avatar" />
+```
+
+...or even an image from an entirely different website:
+```
+<img src="qortal://WEBSITE/AlphaX/assets/img/logo.png" />
+```
+
+
+# Section 2: Integrating a Javascript app
+
+Javascript apps allow for much more complex integrations with Qortal's blockchain data.
+
+## Section 2a: Direct API calls
+
+The standard [Qortal Core API](http://localhost:12391/api-documentation) is available to websites and apps, and can be called directly using a standard AJAX request, such as:
+```
+async function getNameInfo(name) {
+    const response = await fetch("/names/" + name);
+    const nameData = await response.json();
+    console.log("nameData: " + JSON.stringify(nameData));
+}
+getNameInfo("QortalDemo");
+```
+
+However, this only works for read-only data, such as looking up transactions, names, balances, etc. Also, since the address of the logged in account can't be retrieved from the core, apps can't show personalized data with this approach.
+
+
+## Section 2b: User interaction via qortalRequest()
+
+To take things a step further, the qortalRequest() function can be used to interact with the user, in order to:
+
+- Request address and public key of the logged in account
+- Publish data to QDN
+- Send chat messages
+- Join groups
+- Deploy ATs (smart contracts)
+- Send QORT or any supported foreign coin
+- Add/remove items from lists
+
+In addition to the above, qortalRequest() also supports many read-only functions that are also available via direct core API calls. Using qortalRequest() helps with futureproofing, as the core APIs can be modified without breaking functionality of existing Q-Apps.
+
+
+### Making a request
+
+Qortal core will automatically inject the `qortalRequest()` javascript function to all websites/apps, which returns a Promise. This can be used to fetch data or publish data to the Qortal blockchain. This functionality supports async/await, as well as try/catch error handling.
+
+```
+async function myfunction() {
+    try {
+        let res = await qortalRequest({
+            action: "GET_ACCOUNT_DATA",
+            address: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2"
+        });
+        console.log(JSON.stringify(res)); // Log the response to the console
+    
+    } catch(e) {
+        console.log("Error: " + JSON.stringify(e));
+    }
+}
+myfunction();
+```
+
+### Timeouts
+
+Request timeouts are handled automatically when using qortalRequest(). The timeout value will differ based on the action being used - see `getDefaultTimeout()` in [q-apps.js](src/main/resources/q-apps/q-apps.js) for the current values.
+
+If a request times out it will throw an error - `The request timed out` - which can be handled by the Q-App.
+
+It is also possible to specify a custom timeout using `qortalRequestWithTimeout(request, timeout)`, however this is discouraged. It's more reliable and futureproof to let the core handle the timeout values.
+
+
+# Section 3: qortalRequest Documentation
+
+## Supported actions
+
+Here is a list of currently supported actions:
+- GET_USER_ACCOUNT
+- GET_ACCOUNT_DATA
+- GET_ACCOUNT_NAMES
+- SEARCH_NAMES
+- GET_NAME_DATA
+- LIST_QDN_RESOURCES
+- SEARCH_QDN_RESOURCES
+- GET_QDN_RESOURCE_STATUS
+- GET_QDN_RESOURCE_PROPERTIES
+- GET_QDN_RESOURCE_METADATA
+- GET_QDN_RESOURCE_URL
+- LINK_TO_QDN_RESOURCE
+- FETCH_QDN_RESOURCE
+- PUBLISH_QDN_RESOURCE
+- PUBLISH_MULTIPLE_QDN_RESOURCES
+- DECRYPT_DATA
+- SAVE_FILE
+- GET_WALLET_BALANCE
+- GET_BALANCE
+- SEND_COIN
+- SEARCH_CHAT_MESSAGES
+- SEND_CHAT_MESSAGE
+- LIST_GROUPS
+- JOIN_GROUP
+- DEPLOY_AT
+- GET_AT
+- GET_AT_DATA
+- LIST_ATS
+- FETCH_BLOCK
+- FETCH_BLOCK_RANGE
+- SEARCH_TRANSACTIONS
+- GET_PRICE
+- GET_LIST_ITEMS
+- ADD_LIST_ITEMS
+- DELETE_LIST_ITEM
+
+More functionality will be added in the future.
+
+## Example Requests
+
+Here are some example requests for each of the above:
+
+### Get address of logged in account
+_Will likely require user approval_
+```
+let account = await qortalRequest({
+     action: "GET_USER_ACCOUNT"
+});
+let address = account.address;
+```
+
+### Get public key of logged in account
+_Will likely require user approval_
+```
+let pubkey = await qortalRequest({
+     action: "GET_USER_ACCOUNT"
+});
+let publicKey = account.publicKey;
+```
+
+### Get account data
+```
+let res = await qortalRequest({
+    action: "GET_ACCOUNT_DATA",
+    address: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2"
+});
+```
+
+### Get names owned by account
+```
+let res = await qortalRequest({
+    action: "GET_ACCOUNT_NAMES",
+    address: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2"
+});
+```
+
+### Search names
+```
+let res = await qortalRequest({
+    action: "SEARCH_NAMES",
+    query: "search query goes here",
+    prefix: false, // Optional - if true, only the beginning of the name is matched
+    limit: 100,
+    offset: 0,
+    reverse: false
+});
+```
+
+### Get name data
+```
+let res = await qortalRequest({
+    action: "GET_NAME_DATA",
+    name: "QortalDemo"
+});
+```
+
+
+### List QDN resources
+```
+let res = await qortalRequest({
+    action: "LIST_QDN_RESOURCES",
+    service: "THUMBNAIL",
+    name: "QortalDemo", // Optional (exact match)
+    identifier: "qortal_avatar", // Optional (exact match)
+    default: true, // Optional
+    includeStatus: false, // Optional - will take time to respond, so only request if necessary
+    includeMetadata: false, // Optional - will take time to respond, so only request if necessary
+    followedOnly: false, // Optional - include followed names only
+    excludeBlocked: false, // Optional - exclude blocked content
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Search QDN resources
+```
+let res = await qortalRequest({
+    action: "SEARCH_QDN_RESOURCES",
+    service: "THUMBNAIL",
+    query: "search query goes here", // Optional - searches both "identifier" and "name" fields
+    identifier: "search query goes here", // Optional - searches only the "identifier" field
+    name: "search query goes here", // Optional - searches only the "name" field
+    prefix: false, // Optional - if true, only the beginning of fields are matched in all of the above filters
+    exactMatchNames: true, // Optional - if true, partial name matches are excluded
+    default: false, // Optional - if true, only resources without identifiers are returned
+    mode: "LATEST", // Optional - whether to return all resources or just the latest for a name/service combination. Possible values: ALL,LATEST. Default: LATEST
+    minLevel: 1, // Optional - whether to filter results by minimum account level
+    includeStatus: false, // Optional - will take time to respond, so only request if necessary
+    includeMetadata: false, // Optional - will take time to respond, so only request if necessary
+    nameListFilter: "QApp1234Subscriptions", // Optional - will only return results if they are from a name included in supplied list
+    followedOnly: false, // Optional - include followed names only
+    excludeBlocked: false, // Optional - exclude blocked content
+    // before: 1683546000000, // Optional - limit to resources created before timestamp
+    // after: 1683546000000, // Optional - limit to resources created after timestamp
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Search QDN resources (multiple names)
+```
+let res = await qortalRequest({
+    action: "SEARCH_QDN_RESOURCES",
+    service: "THUMBNAIL",
+    query: "search query goes here", // Optional - searches both "identifier" and "name" fields
+    identifier: "search query goes here", // Optional - searches only the "identifier" field
+    names: ["QortalDemo", "crowetic", "AlphaX"], // Optional - searches only the "name" field for any of the supplied names
+    prefix: false, // Optional - if true, only the beginning of fields are matched in all of the above filters
+    exactMatchNames: true, // Optional - if true, partial name matches are excluded
+    default: false, // Optional - if true, only resources without identifiers are returned
+    mode: "LATEST", // Optional - whether to return all resources or just the latest for a name/service combination. Possible values: ALL,LATEST. Default: LATEST
+    includeStatus: false, // Optional - will take time to respond, so only request if necessary
+    includeMetadata: false, // Optional - will take time to respond, so only request if necessary
+    nameListFilter: "QApp1234Subscriptions", // Optional - will only return results if they are from a name included in supplied list
+    followedOnly: false, // Optional - include followed names only
+    excludeBlocked: false, // Optional - exclude blocked content
+    // before: 1683546000000, // Optional - limit to resources created before timestamp
+    // after: 1683546000000, // Optional - limit to resources created after timestamp
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Fetch QDN single file resource
+```
+let res = await qortalRequest({
+    action: "FETCH_QDN_RESOURCE",
+    name: "QortalDemo",
+    service: "THUMBNAIL",
+    identifier: "qortal_avatar", // Optional. If omitted, the default resource is returned, or you can alternatively use the keyword "default"
+    encoding: "base64", // Optional. If omitted, data is returned in raw form
+    rebuild: false
+});
+```
+
+### Fetch file from multi file QDN resource
+Data is returned in the base64 format
+```
+let res = await qortalRequest({
+    action: "FETCH_QDN_RESOURCE",
+    name: "QortalDemo",
+    service: "WEBSITE",
+    identifier: "default", // Optional. If omitted, the default resource is returned, or you can alternatively request that using the keyword "default", as shown here
+    filepath: "index.html", // Required only for resources containing more than one file
+    rebuild: false
+});
+```
+
+### Get QDN resource status
+```
+let res = await qortalRequest({
+    action: "GET_QDN_RESOURCE_STATUS",
+    name: "QortalDemo",
+    service: "THUMBNAIL",
+    identifier: "qortal_avatar", // Optional
+    build: true // Optional - request that the resource is fetched & built in the background
+});
+```
+
+### Get QDN resource properties
+```
+let res = await qortalRequest({
+    action: "GET_QDN_RESOURCE_PROPERTIES",
+    name: "QortalDemo",
+    service: "THUMBNAIL",
+    identifier: "qortal_avatar" // Optional
+});
+// Returns: filename, size, mimeType (where available)
+```
+
+### Get QDN resource metadata
+```
+let res = await qortalRequest({
+    action: "GET_QDN_RESOURCE_METADATA",
+    name: "QortalDemo",
+    service: "THUMBNAIL",
+    identifier: "qortal_avatar" // Optional
+});
+```
+
+### Publish a single file to QDN
+_Requires user approval_.<br />
+Note: this publishes a single, base64-encoded file. Multi-file resource publishing (such as a WEBSITE or GIF_REPOSITORY) is not yet supported via a Q-App. It will be added in a future update.
+```
+let res = await qortalRequest({
+    action: "PUBLISH_QDN_RESOURCE",
+    name: "Demo", // Publisher must own the registered name - use GET_ACCOUNT_NAMES for a list
+    service: "IMAGE",
+    identifier: "myapp-image1234" // Optional
+    data64: "base64_encoded_data",
+    // filename: "image.jpg", // Optional - to help apps determine the file's type
+    // title: "Title", // Optional
+    // description: "Description", // Optional
+    // category: "TECHNOLOGY", // Optional
+    // tag1: "any", // Optional
+    // tag2: "strings", // Optional
+    // tag3: "can", // Optional
+    // tag4: "go", // Optional
+    // tag5: "here", // Optional
+    // encrypt: true, // Optional - to be used with a private service
+    // recipientPublicKey: "publickeygoeshere" // Only required if `encrypt` is set to true
+});
+```
+
+### Publish multiple resources at once to QDN
+_Requires user approval_.<br />
+Note: each resource being published consists of a single, base64-encoded file, each in its own transaction. Useful for publishing two or more related things, such as a video and a video thumbnail.
+```
+let res = await qortalRequest({
+    action: "PUBLISH_MULTIPLE_QDN_RESOURCES",
+    resources: [
+        name: "Demo", // Publisher must own the registered name - use GET_ACCOUNT_NAMES for a list
+        service: "IMAGE",
+        identifier: "myapp-image1234" // Optional
+        data64: "base64_encoded_data",
+        // filename: "image.jpg", // Optional - to help apps determine the file's type
+        // title: "Title", // Optional
+        // description: "Description", // Optional
+        // category: "TECHNOLOGY", // Optional
+        // tag1: "any", // Optional
+        // tag2: "strings", // Optional
+        // tag3: "can", // Optional
+        // tag4: "go", // Optional
+        // tag5: "here", // Optional
+        // encrypt: true, // Optional - to be used with a private service
+        // recipientPublicKey: "publickeygoeshere" // Only required if `encrypt` is set to true
+    ],
+    [
+        ... more resources here if needed ...
+    ]
+});
+```
+
+### Decrypt encrypted/private data
+```
+let res = await qortalRequest({
+    action: "DECRYPT_DATA",
+    encryptedData: 'qortalEncryptedDatabMx4fELNTV+ifJxmv4+GcuOIJOTo+3qAvbWKNY2L1r',
+    publicKey: 'publickeygoeshere'
+});
+// Returns base64 encoded string of plaintext data
+```
+
+### Prompt user to save a file to disk
+Note: mimeType not required but recommended. If not specified, saving will fail if the mimeType is unable to be derived from the Blob.
+```
+let res = await qortalRequest({
+    action: "SAVE_FILE",
+    blob: dataBlob,
+    filename: "myfile.pdf",
+    mimeType: "application/pdf" // Optional but recommended
+});
+```
+
+
+### Get wallet balance (QORT)
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "GET_WALLET_BALANCE",
+    coin: "QORT"
+});
+```
+
+
+### Get address or asset balance
+```
+let res = await qortalRequest({
+    action: "GET_BALANCE",
+    address: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2"
+});
+```
+```
+let res = await qortalRequest({
+    action: "GET_BALANCE",
+    assetId: 1,
+    address: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2"
+});
+```
+
+### Send QORT to address
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "SEND_COIN",
+    coin: "QORT",
+    destinationAddress: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2",
+    amount: 1.00000000 // 1 QORT
+});
+```
+
+### Send foreign coin to address
+_Requires user approval_<br />
+Note: default fees can be found [here](https://github.com/Qortal/qortal-ui/blob/master/plugins/plugins/core/qdn/browser/browser.src.js#L205-L209).
+```
+let res = await qortalRequest({
+    action: "SEND_COIN",
+    coin: "LTC",
+    destinationAddress: "LSdTvMHRm8sScqwCi6x9wzYQae8JeZhx6y",
+    amount: 1.00000000, // 1 LTC
+    fee: 0.00000020 // Optional fee per byte (default fee used if omitted, recommended) - not used for QORT or ARRR
+});
+```
+
+### Search or list chat messages
+```
+let res = await qortalRequest({
+    action: "SEARCH_CHAT_MESSAGES",
+    before: 999999999999999,
+    after: 0,
+    txGroupId: 0, // Optional (must specify either txGroupId or two involving addresses)
+    // involving: ["QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2", "QSefrppsDCsZebcwrqiM1gNbWq7YMDXtG2"], // Optional (must specify either txGroupId or two involving addresses)
+    // reference: "reference", // Optional
+    // chatReference: "chatreference", // Optional
+    // hasChatReference: true, // Optional
+    encoding: "BASE64", // Optional (defaults to BASE58 if omitted)
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Send a group chat message
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "SEND_CHAT_MESSAGE",
+    groupId: 0,
+    message: "Test"
+});
+```
+
+### Send a private chat message
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "SEND_CHAT_MESSAGE",
+    destinationAddress: "QZLJV7wbaFyxaoZQsjm6rb9MWMiDzWsqM2",
+    message: "Test"
+});
+```
+
+### List groups
+```
+let res = await qortalRequest({
+    action: "LIST_GROUPS",
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Join a group
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "JOIN_GROUP",
+    groupId: 100
+});
+```
+
+
+### Deploy an AT
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "DEPLOY_AT",
+    creationBytes: "12345", // Must be Base58 encoded
+    name: "test name",
+    description: "test description",
+    type: "test type",
+    tags: "test tags",
+    amount: 1.00000000, // 1 QORT
+    assetId: 0,
+    // fee: 0.002 // optional - will use default fee if excluded
+});
+```
+
+### Get AT info
+```
+let res = await qortalRequest({
+    action: "GET_AT",
+    atAddress: "ASRUsCjk6fa5bujv3oWYmWaVqNtvxydpPH"
+});
+```
+
+### Get AT data bytes (base58 encoded)
+```
+let res = await qortalRequest({
+    action: "GET_AT_DATA",
+    atAddress: "ASRUsCjk6fa5bujv3oWYmWaVqNtvxydpPH"
+});
+```
+
+### List ATs by functionality
+```
+let res = await qortalRequest({
+    action: "LIST_ATS",
+    codeHash58: "4KdJETRAdymE7dodDmJbf5d9L1bp4g5Nxky8m47TBkvA",
+    isExecutable: true,
+    limit: 100,
+    offset: 0,
+    reverse: true
+});
+```
+
+### Fetch block by signature
+```
+let res = await qortalRequest({
+    action: "FETCH_BLOCK",
+    signature: "875yGFUy1zHV2hmxNWzrhtn9S1zkeD7SQppwdXFysvTXrankCHCz4iyAUgCBM3GjvibbnyRQpriuy1cyu953U1u5uQdzuH3QjQivi9UVwz86z1Akn17MGd5Z5STjpDT7248K6vzMamuqDei57Znonr8GGgn8yyyABn35CbZUCeAuXju"
+});
+```
+
+### Fetch block by height
+```
+let res = await qortalRequest({
+    action: "FETCH_BLOCK",
+    height: "1139850"
+});
+```
+
+### Fetch a range of blocks
+```
+let res = await qortalRequest({
+    action: "FETCH_BLOCK_RANGE",
+    height: "1139800",
+    count: 20,
+    reverse: false
+});
+```
+
+### Search transactions
+```
+let res = await qortalRequest({
+    action: "SEARCH_TRANSACTIONS",
+    // startBlock: 1139000,
+    // blockLimit: 1000,
+    txGroupId: 0,
+    txType: [
+        "PAYMENT",
+        "REWARD_SHARE"
+    ],
+    confirmationStatus: "CONFIRMED",
+    limit: 10,
+    offset: 0,
+    reverse: false
+});
+```
+
+### Get an estimate of the QORT price
+```
+let res = await qortalRequest({
+    action: "GET_PRICE",
+    blockchain: "LITECOIN",
+    // maxtrades: 10,
+    inverse: true
+});
+```
+
+### Get URL to load a QDN resource
+Note: this returns a "Resource does not exist" error if a non-existent resource is requested.
+```
+let url = await qortalRequest({
+    action: "GET_QDN_RESOURCE_URL",
+    service: "THUMBNAIL",
+    name: "QortalDemo",
+    identifier: "qortal_avatar"
+    // path: "filename.jpg" // optional - not needed if resource contains only one file
+});
+```
+
+### Get URL to load a QDN website
+Note: this returns a "Resource does not exist" error if a non-existent resource is requested.
+```
+let url = await qortalRequest({
+    action: "GET_QDN_RESOURCE_URL",
+    service: "WEBSITE",
+    name: "QortalDemo",
+});
+```
+
+### Get URL to load a specific file from a QDN website
+Note: this returns a "Resource does not exist" error if a non-existent resource is requested.
+```
+let url = await qortalRequest({
+    action: "GET_QDN_RESOURCE_URL",
+    service: "WEBSITE",
+    name: "AlphaX",
+    path: "/assets/img/logo.png"
+});
+```
+
+### Link/redirect to another QDN website
+Note: an alternate method is to include `<a href="qortal://WEBSITE/QortalDemo">link text</a>` within your HTML code.
+```
+let res = await qortalRequest({
+    action: "LINK_TO_QDN_RESOURCE",
+    service: "WEBSITE",
+    name: "QortalDemo",
+});
+```
+
+### Link/redirect to a specific path of another QDN website
+Note: an alternate method is to include `<a href="qortal://WEBSITE/QortalDemo/minting-leveling/index.html">link text</a>` within your HTML code.
+```
+let res = await qortalRequest({
+    action: "LINK_TO_QDN_RESOURCE",
+    service: "WEBSITE",
+    name: "QortalDemo",
+    path: "/minting-leveling/index.html"
+});
+```
+
+### Get the contents of a list
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "GET_LIST_ITEMS",
+    list_name: "followedNames"
+});
+```
+
+### Add one or more items to a list
+_Requires user approval_
+```
+let res = await qortalRequest({
+    action: "ADD_LIST_ITEMS",
+    list_name: "blockedNames",
+    items: ["QortalDemo"]
+});
+```
+
+### Delete a single item from a list
+_Requires user approval_.
+Items must be deleted one at a time.
+```
+let res = await qortalRequest({
+    action: "DELETE_LIST_ITEM",
+    list_name: "blockedNames",
+    item: "QortalDemo"
+});
+```
+
+
+# Section 4: Examples
+
+Some example projects can be found [here](https://github.com/Qortal/Q-Apps). These can be cloned and modified, or used as a reference when creating a new app.
+
+
+## Sample App
+
+Here is a sample application to display the logged-in user's avatar:
+```
+<html>
+<head>
+    <script>
+        async function showAvatar() {
+            try {
+                // Get QORT address of logged in account
+                let account = await qortalRequest({
+                    action: "GET_USER_ACCOUNT"
+                });
+                let address = account.address;
+                console.log("address: " + address);
+            
+                // Get names owned by this account
+                let names = await qortalRequest({
+                    action: "GET_ACCOUNT_NAMES",
+                    address: address
+                });
+                console.log("names: " + JSON.stringify(names));
+            
+                if (names.length == 0) {
+                    console.log("User has no registered names");
+                    return;
+                }
+            
+                // Download base64-encoded avatar of the first registered name
+                let avatar = await qortalRequest({
+                    action: "FETCH_QDN_RESOURCE",
+                    name: names[0].name,
+                    service: "THUMBNAIL",
+                    identifier: "qortal_avatar",
+                    encoding: "base64"
+                });
+                console.log("Avatar size: " + avatar.length + " bytes");
+            
+                // Display the avatar image on the screen
+                document.getElementById("avatar").src = "data:image/png;base64," + avatar;
+                
+            } catch(e) {
+                console.log("Error: " + JSON.stringify(e));
+            }
+        }
+    </script>
+</head>
+<body onload="showAvatar()">
+    <img width="500" id="avatar" />
+</body>
+</html>
+```
+
+
+# Section 5: Testing and Development
+
+Publishing an in-development app to mainnet isn't recommended. There are several options for developing and testing a Q-app before publishing to mainnet:
+
+### Preview mode
+
+Select "Preview" in the UI after choosing the zip. This allows for full Q-App testing without the need to publish any data.
+
+
+### Testnets
+
+For an end-to-end test of Q-App publishing, you can use the official testnet, or set up a single node testnet of your own (often referred to as devnet) on your local machine. See [Single Node Testnet Quick Start Guide](testnet/README.md#quick-start).
+
+
+### Debugging
+
+It is recommended that you develop and test in a web browser, to allow access to the javascript console. To do this:
+1. Open the UI app, then minimise it.
+2. In a Chromium-based web browser, visit: http://localhost:12388/
+3. Log in to your account and then preview your app/website.
+4. Go to `View > Developer > JavaScript Console`. Here you can monitor console logs, errors, and network requests from your app, in the same way as any other web-app.

README.md

@@ -1,12 +1,56 @@
-# Qortal Project - Official Repo
+# Qortal Project - Qortal Core - Primary Repository
+The Qortal Core is the blockchain and node component of the overall project. It contains the primary API, and ability to make calls to create transactions, and interact with the Qortal Blockchain Network. 
 
-## Build / run
+In order to run the Qortal Core, a machine with java 11+ installed is required. Minimum RAM specs will vary depending on settings, but as low as 4GB of RAM should be acceptable in most scenarios. 
+
+Qortal is a complete infrastructure platform with a blockchain backend, it is capable of indefinite web and application hosting with no continual fees, replacement of DNS and centralized name systems and communications systems, and is the foundation of the next generation digital infrastructure of the world. Qortal is unique in nearly every way, and was written from scratch to address as many concerns from both the existing 'blockchain space' and the 'typical internet' as possible, while maintaining a system that is easy to use and able to run on 'any' computer. 
+
+Qortal contains extensive functionality geared toward complete decentralization of the digital world. Removal of 'middlemen' of any kind from all transactions, and ability to publish websites and applications that require no continual fees, on a name that is truly owned by the account that registered it, or purchased it from another. A single name on Qortal is capable of being both a namespace and a 'username'. That single name can have an application, website, public and private data, communications, authentication, the namespace itself and more, which can subsequently be sold to anyone else without the need to change any type of 'hosting' or DNS entries that do not exist, email that doesn't exist, etc. Maintaining the same functionality as those replaced features of web 2.0. 
+
+Over time Qortal has progressed into a fully featured environment catering to any and all types of people and organizations, and will continue to advance as time goes on. Brining more features, capability, device support, and availale replacements for web2.0. Ultimately building a new, completely user-controlled digital world without limits. 
+
+Qortal has no owner, no company on top of it, and is completely community built, run, and funded. A community-established and run group of developers known as the 'dev-group' or Qortal Development Group, make group_approval based decisions for the project's future. If you are a developer interested in assisting with the project, you meay reach out to the Qortal Development Group in any of the available Qortal community locations. Either on the Qortal network itself, or on one of the temporary centralized social media locations. 
+
+Building the future one block at a time. Welcome to Qortal. 
+
+# Building the Qortal Core from Source
+
+## Build / Run
 
 - Requires Java 11. OpenJDK 11 recommended over Java SE.
 - Install Maven
 - Use Maven to fetch dependencies and build: `mvn clean package`
+- Update Maven dependencies: `mvn install` 
 - Built JAR should be something like `target/qortal-1.0.jar`
 - Create basic *settings.json* file: `echo '{}' > settings.json`
 - Run JAR in same working directory as *settings.json*: `java -jar target/qortal-1.0.jar`
 - Wrap in shell script, add JVM flags, redirection, backgrounding, etc. as necessary.
 - Or use supplied example shell script: *start.sh*
+
+## IntelliJ IDEA Configuration
+
+- Run -> Edit Configurations
+- Add New Application
+- Name: qortal
+- SDK: java 11
+- Main Class: org.qortal.controller.Controller
+- Program arguments: settings.json -Dlog4j.configurationFile=log4j2.properties -ea
+- Environment variables: Djava.net.preferIPv4Stack=false
+
+# Using a pre-built Qortal 'jar' binary
+
+If you prefer to utilize a released version of Qortal, you may do so by downloading one of the available releases from the releases page, that are also linked on https://qortal.org and https://qortal.dev. 
+
+# Learning Q-App Development
+
+https://qortal.dev contains dev documentation for building JS/React (and other client-side languages) applications or 'Q-Apps' on Qortal. Q-Apps are published on Registered Qortal Names, and aside from a single Name Registration fee, and a fraction of QORT for a publish transaction, require zero continual costs. These applications get more redundant with each new access from a new Qortal Node, making your application faster for the next user to download, and stronger as time goes on. Q-Apps live indefinitely in the history of the blockchain-secured Qortal Data Network (QDN).
+
+# How to learn more
+
+If the project interests you, you may learn more from the various web2 and QDN based websites focused on introductory information. 
+
+https://qortal.org - primary internet presence 
+https://qortal.dev - secondary and development focused website with links to many new developments and documentation
+https://wiki.qortal.org - community built and managed wiki with detailed information regarding the project
+
+links to telegram and discord communities are at the top of https://qortal.org as well. 

WindowsInstaller/Install Files/AppData/settings.json

@@ -1,3 +1,4 @@
 {
-  "apiDocumentationEnabled": true
+  "apiDocumentationEnabled": true,
+  "apiWhitelistEnabled": false
 }

WindowsInstaller/Install Files/log4j2.properties

@@ -1,7 +1,7 @@
 rootLogger.level = info
 # On Windows, uncomment next line to set dirname:
 # property.dirname = ${sys:user.home}\\AppData\\Local\\qortal\\
-property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
+# property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
 
 rootLogger.appenderRef.console.ref = stdout
 rootLogger.appenderRef.rolling.ref = FILE
@@ -59,11 +59,14 @@ appender.console.filter.threshold.level = error
 
 appender.rolling.type = RollingFile
 appender.rolling.name = FILE
+appender.rolling.fileName = qortal.log
+appender.rolling.filePattern = qortal.%d{dd-MMM}.log.gz
 appender.rolling.layout.type = PatternLayout
 appender.rolling.layout.pattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
-appender.rolling.filePattern = ./${filename}.%i
 appender.rolling.policy.type = SizeBasedTriggeringPolicy
-appender.rolling.policy.size = 4MB
+appender.rolling.policy.size = 10MB
+appender.rolling.strategy.type = DefaultRolloverStrategy
+appender.rolling.strategy.max = 7
 # Set the immediate flush to true (default)
 # appender.rolling.immediateFlush = true
 # Set the append to true (default), should not overwrite

WindowsInstaller/README.md

@@ -2,23 +2,29 @@
 
 ## Prerequisites
 
-* AdvancedInstaller v16 or better, and enterprise licence if translations are required
-* Installed AdoptOpenJDK v11 64bit, full JDK *not* JRE
+* AdvancedInstaller v19.4 or better, and enterprise licence. 
+* Qortal has an open source license, however it currently (as of December 2024) only supports up to version 19. (We may need to reach out to Advanced Installer again to obtain a new license at some point, if needed. 
+* Reach out to @crowetic for links to the installer install files, and license. 
+* Installed AdoptOpenJDK v17 64bit, full JDK *not* JRE
 
 ## General build instructions
 
 If this is your first time opening the `qortal.aip` file then you might need to adjust
 configured paths, or create a dummy `D:` drive with the expected layout.
 
+Opening the aip file from within a clone of the qortal repo also works, if you have a separate windows machine setup to do the build. 
+
+You May need to change the location of the 'jre64' files inside Advanced Installer, if it is set to a path that your build machine doesn't have. 
+
+The Java Memory Arguments can be set manually, but as of December 2024 they have been reset back to system defaults. This should include G1GC Garbage Collector.
+
 Typical build procedure:
 
 * Place the `qortal.jar` file in `Install-Files\`
 * Open AdvancedInstaller with qortal.aip file
 * If releasing a new version, change version number in:
-	+ "Product Information" side menu
 	+ "Product Details" side menu entry
 	+ "Product Details" tab in "Product Details" pane
-	+ "Product Version" entry box
 * Click away to a different side menu entry, e.g. "Resources" -> "Files and Folders"
 * You should be prompted whether to generate a new product key, click "Generate New"
 * Click "Build" button

lib/com/dosse/WaifUPnP/1.2/WaifUPnP-1.2.pom

@@ -2,8 +2,8 @@
 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.4.0</version>
+  <groupId>com.dosse</groupId>
+  <artifactId>WaifUPnP</artifactId>
+  <version>1.2</version>
   <description>POM was created from install:install-file</description>
 </project>

lib/com/dosse/WaifUPnP/maven-metadata-local.xml

@@ -3,10 +3,11 @@
   <groupId>com.dosse</groupId>
   <artifactId>WaifUPnP</artifactId>
   <versioning>
-    <release>1.1</release>
+    <release>1.2</release>
     <versions>
       <version>1.1</version>
+      <version>1.2</version>
     </versions>
-    <lastUpdated>20220218200127</lastUpdated>
+    <lastUpdated>20231026200127</lastUpdated>
   </versioning>
 </metadata>

lib/org/ciyam/AT/1.3.7/AT-1.3.7.pom

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.3.7</version>
-  <description>POM was created from install:install-file</description>
-</project>

lib/org/ciyam/AT/1.3.8/AT-1.3.8.pom

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.3.8</version>
-  <description>POM was created from install:install-file</description>
-</project>

lib/org/ciyam/AT/maven-metadata-local.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<metadata>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <versioning>
-    <release>1.4.0</release>
-    <versions>
-      <version>1.3.4</version>
-      <version>1.3.5</version>
-      <version>1.3.6</version>
-      <version>1.3.7</version>
-      <version>1.3.8</version>
-      <version>1.4.0</version>
-    </versions>
-    <lastUpdated>20221105114346</lastUpdated>
-  </versioning>
-</metadata>

lib/org/hsqldb/hsqldb/2.7.4/Notes.txt

@@ -0,0 +1,5 @@
+This is the production hsqldb-2.7.4 with the manifest file updated 
+
+Sealed: false
+
+Allows the addition of the custom Qortal HSQLDBPool and Monitoring Classes

log4j2.properties

@@ -1,7 +1,7 @@
 rootLogger.level = info
 # On Windows, uncomment next line to set dirname:
 # property.dirname = ${sys:user.home}\\AppData\\Local\\qortal\\
-property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
+# property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
 
 rootLogger.appenderRef.console.ref = stdout
 rootLogger.appenderRef.rolling.ref = FILE
@@ -59,11 +59,14 @@ appender.console.filter.threshold.level = error
 
 appender.rolling.type = RollingFile
 appender.rolling.name = FILE
+appender.rolling.fileName = qortal.log
+appender.rolling.filePattern = qortal.%d{dd-MMM}.log.gz
 appender.rolling.layout.type = PatternLayout
 appender.rolling.layout.pattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
-appender.rolling.filePattern = ./${filename}.%i
 appender.rolling.policy.type = SizeBasedTriggeringPolicy
-appender.rolling.policy.size = 4MB
+appender.rolling.policy.size = 10MB
+appender.rolling.strategy.type = DefaultRolloverStrategy
+appender.rolling.strategy.max = 7
 # Set the immediate flush to true (default)
 # appender.rolling.immediateFlush = true
 # Set the append to true (default), should not overwrite

pom.xml

@@ -3,39 +3,69 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>3.8.4</version>
+	<version>5.1.0</version> <!-- Version must be <X.Y.Z> -->
 	<packaging>jar</packaging>
 	<properties>
-		<skipTests>true</skipTests>
-		<altcoinj.version>7dc8c6f</altcoinj.version>
-		<bitcoinj.version>0.15.10</bitcoinj.version>
-		<bouncycastle.version>1.69</bouncycastle.version>
-		<build.timestamp>${maven.build.timestamp}</build.timestamp>
-		<ciyam-at.version>1.4.0</ciyam-at.version>
-		<commons-net.version>3.6</commons-net.version>
-		<commons-text.version>1.8</commons-text.version>
-		<commons-io.version>2.6</commons-io.version>
-		<commons-compress.version>1.21</commons-compress.version>
-		<commons-lang3.version>3.12.0</commons-lang3.version>
-		<xz.version>1.9</xz.version>
-		<dagger.version>1.2.2</dagger.version>
-		<guava.version>28.1-jre</guava.version>
-		<hsqldb.version>2.5.1</hsqldb.version>
-		<homoglyph.version>1.2.1</homoglyph.version>
-		<icu4j.version>70.1</icu4j.version>
-		<upnp.version>1.1</upnp.version>
-		<jersey.version>2.29.1</jersey.version>
-		<jetty.version>9.4.29.v20200521</jetty.version>
-		<log4j.version>2.17.1</log4j.version>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<slf4j.version>1.7.12</slf4j.version>
-		<swagger-api.version>2.0.9</swagger-api.version>
-		<swagger-ui.version>3.23.8</swagger-ui.version>
-		<package-info-maven-plugin.version>1.1.0</package-info-maven-plugin.version>
-		<jsoup.version>1.13.1</jsoup.version>
-		<java-diff-utils.version>4.10</java-diff-utils.version>
-		<grpc.version>1.45.1</grpc.version>
-		<protobuf.version>3.19.4</protobuf.version>
+		<skipJUnitTests>true</skipJUnitTests>
+		
+		<altcoinj.version>d7cf6ac</altcoinj.version> <!-- BC v16 / Updated Abstract Classes / alertSigningKey -->
+		<bitcoinj.version>0.16.3</bitcoinj.version>
+		<bouncycastle.version>1.73</bouncycastle.version>
+		<build.timestamp>${maven.build.timestamp}</build.timestamp>
+		<ciyam-at.version>1b731d1</ciyam-at.version> <!-- This is the hash for v1.4.3 -->
+		<commons-net.version>3.8.0</commons-net.version>
+		<!-- <commons-net.version>3.9.0</commons-net.version> v5.2.0 coming soon -->
+		<commons-text.version>1.12.0</commons-text.version>
+		<commons-io.version>2.18.0</commons-io.version>
+		<commons-compress.version>1.27.1</commons-compress.version>
+		<commons-lang3.version>3.17.0</commons-lang3.version>
+		<dagger.version>1.2.2</dagger.version>
+		<extendedset.version>0.12.3</extendedset.version>
+		<git-commit-id-plugin.version>4.9.10</git-commit-id-plugin.version>
+		<grpc.version>1.68.1</grpc.version>
+		<!-- <grpc.version>1.68.3</grpc.version> v5.2.0 coming soon -->
+		<guava.version>33.3.1-jre</guava.version>
+		<hamcrest-library.version>2.2</hamcrest-library.version>
+		<homoglyph.version>1.2.1</homoglyph.version>
+		<hsqldb.version>2.7.4</hsqldb.version>
+		<icu4j.version>76.1</icu4j.version>
+		<java-diff-utils.version>4.15</java-diff-utils.version>
+		<javax.servlet-api.version>4.0.1</javax.servlet-api.version>
+		<jaxb-runtime.version>2.3.9</jaxb-runtime.version>
+		<jersey.version>2.42</jersey.version>
+		<jetty.version>9.4.56.v20240826</jetty.version>
+		<!-- <jetty.version>9.4.57.v20241219</jetty.version> v5.2.0 Coming Soon -->
+		<json-simple.version>1.1.1</json-simple.version>
+		<json.version>20240303</json.version>
+		<jsoup.version>1.18.1</jsoup.version>
+		<junit-jupiter-engine.version>5.11.0-M2</junit-jupiter-engine.version>
+		<lifecycle-mapping.version>1.0.0</lifecycle-mapping.version>
+		<log4j.version>2.23.1</log4j.version>
+		<mail.version>1.5.0-b01</mail.version>
+		<maven-build-helper-plugin.version>3.6.0</maven-build-helper-plugin.version>
+		<maven-compiler-plugin.version>3.13.0</maven-compiler-plugin.version>
+		<maven-dependency-plugin.version>3.6.1</maven-dependency-plugin.version>
+		<maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
+		<maven-package-info-plugin.version>1.1.0</maven-package-info-plugin.version>
+		<maven-plugin.version>2.18.0</maven-plugin.version>
+		<maven-reproducible-build-plugin.version>0.17</maven-reproducible-build-plugin.version>
+		<maven-resources-plugin.version>3.3.1</maven-resources-plugin.version>
+		<maven-shade-plugin.version>3.6.0</maven-shade-plugin.version>
+		<maven-install-plugin.version>3.1.3</maven-install-plugin.version>
+		<maven-surefire-plugin.version>3.5.2</maven-surefire-plugin.version>
+		<!-- <maven-surefire-plugin.version>3.5.3</maven-surefire-plugin.version> v5.2.0 Coming Soon -->
+		<protobuf.version>3.25.3</protobuf.version>
+		<!-- <protobuf.version>3.25.7</protobuf.version> v 5.1 -->
+		<replacer.version>1.5.3</replacer.version>
+		<simplemagic.version>1.17</simplemagic.version>
+		<slf4j.version>1.7.36</slf4j.version>
+		<!-- <swagger-api.version>2.2.30</swagger-api.version> need code upgrade Future Release -->
+		<!-- <swagger-api.version>2.1.13</swagger-api.version> need code upgrade Future Release -->
+		<swagger-api.version>2.0.10</swagger-api.version>
+		<swagger-ui.version>5.18.2</swagger-ui.version>
+		<upnp.version>1.2</upnp.version>
+		<xz.version>1.10</xz.version>
 	</properties>
 	<build>
 		<sourceDirectory>src/main/java</sourceDirectory>
@@ -50,14 +80,14 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>versions-maven-plugin</artifactId>
-				<version>2.5</version>
+				<version>${maven-plugin.version}</version>
 				<configuration>
 					<generateBackupPoms>false</generateBackupPoms>
 				</configuration>
 			</plugin>
 			<plugin>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.8.0</version>
+				<version>${maven-compiler-plugin.version}</version>
 				<configuration>
 					<release>11</release>
 				</configuration>
@@ -88,7 +118,7 @@
 			<plugin>
 				<groupId>pl.project13.maven</groupId>
 				<artifactId>git-commit-id-plugin</artifactId>
-				<version>4.0.0</version>
+				<version>${git-commit-id-plugin.version}</version>
 				<executions>
 					<execution>
 						<id>get-the-git-infos</id>
@@ -120,7 +150,7 @@
 			<plugin>
 				<groupId>com.google.code.maven-replacer-plugin</groupId>
 				<artifactId>replacer</artifactId>
-				<version>1.5.3</version>
+				<version>${replacer.version}</version>
 				<executions>
 					<execution>
 						<id>replace-swagger-ui</id>
@@ -131,22 +161,35 @@
 						<inherited>false</inherited>
 						<configuration>
 							<file>${project.build.directory}/swagger-ui.unpacked/META-INF/resources/webjars/swagger-ui/${swagger-ui.version}/index.html</file>
+							<replacements>
+								<replacement>
+									<token>Swagger UI</token>
+									<value>Qortal API Documentation</value>
+								</replacement>
+							</replacements>
+						</configuration>
+					</execution>
+					<execution>
+						<id>replace-swagger-ui-json</id>
+						<phase>generate-resources</phase>
+						<goals>
+							<goal>replace</goal>
+						</goals>
+						<inherited>false</inherited>
+						<configuration>
+							<file>${project.build.directory}/swagger-ui.unpacked/META-INF/resources/webjars/swagger-ui/${swagger-ui.version}/swagger-initializer.js</file>
 							<replacements>
 								<replacement>
 									<token>https://petstore.swagger.io/v2/swagger.json</token>
 									<value>/openapi.json</value>
 								</replacement>
-								<replacement>
-									<token>Swagger UI</token>
-									<value>API Documentation</value>
-								</replacement>
 								<replacement>
 									<token>deepLinking: true,</token>
 									<value>
 										deepLinking: true,
 										tagsSorter: "alpha",
-										operationsSorter:
-										"alpha",
+										operationsSorter: "alpha",
+										validatorUrl: false,
 									</value>
 								</replacement>
 							</replacements>
@@ -162,11 +205,13 @@
 						<configuration>
 							<file>${project.build.outputDirectory}/git.properties</file>
 							<regex>true</regex>
-							<regexFlags><regexFlag>MULTILINE</regexFlag></regexFlags>
+							<regexFlags>
+								<regexFlag>MULTILINE</regexFlag>
+							</regexFlags>
 							<replacements>
 								<replacement>
 									<token>^(#.*$[\n\r]*)</token>
-									<value></value>
+									<value/>
 								</replacement>
 							</replacements>
 						</configuration>
@@ -176,7 +221,10 @@
 			<!-- add swagger-ui as resource to output package -->
 			<plugin>
 				<artifactId>maven-resources-plugin</artifactId>
-				<version>3.1.0</version>
+				<version>${maven-resources-plugin.version}</version>
+				<configuration>
+					<propertiesEncoding>ISO-8859-1</propertiesEncoding>
+				</configuration>
 				<executions>
 					<execution>
 						<id>copy-resources</id>
@@ -200,7 +248,7 @@
 			<plugin>
 				<groupId>com.github.bohnman</groupId>
 				<artifactId>package-info-maven-plugin</artifactId>
-				<version>${package-info-maven-plugin.version}</version>
+				<version>${maven-package-info-plugin.version}</version>
 				<configuration>
 					<packages>
 						<package>
@@ -230,7 +278,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>build-helper-maven-plugin</artifactId>
-				<version>3.0.0</version>
+				<version>${maven-build-helper-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>generate-sources</phase>
@@ -248,31 +296,58 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.2.0</version>
-				<configuration>
-					<archive>
-						<manifest>
-							<addDefaultEntries>false</addDefaultEntries>
-							<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-						</manifest>
-						<manifestEntries>
-							<Last-Commit-Id>${git.commit.id.full}</Last-Commit-Id>
-							<Last-Commit-Time>${git.commit.time}</Last-Commit-Time>
-							<Reproducible-Build>true</Reproducible-Build>
-						</manifestEntries>
-					</archive>
-				</configuration>
+				<version>${maven-jar-plugin.version}</version>
+				<executions>
+					<execution>
+						<configuration>
+							<archive>
+								<manifest>
+									<addDefaultEntries>false</addDefaultEntries>
+									<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+								</manifest>
+								<manifestEntries>
+									<Last-Commit-Id>${git.commit.id.full}</Last-Commit-Id>
+									<Last-Commit-Time>${git.commit.time}</Last-Commit-Time>
+									<Reproducible-Build>true</Reproducible-Build>
+								</manifestEntries>
+							</archive>
+						</configuration>
+					</execution>
+				</executions>
 			</plugin>
+			<!-- Copy modified hsqldb.jar to install / modified MANIFEST.MF-->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-install-plugin</artifactId>
+				<version>${maven-install-plugin.version}</version>
+				<configuration>
+					<groupId>org.hsqldb</groupId>
+					<artifactId>hsqldb</artifactId>
+					<version>${hsqldb.version}</version>
+					<packaging>jar</packaging>
+				</configuration>
+				<executions>
+					<execution>
+						<phase>install</phase>
+						<goals>
+							<goal>install-file</goal>
+						</goals>
+						<configuration>
+							<file>${project.basedir}/lib/org/hsqldb/hsqldb/${hsqldb.version}/hsqldb.jar</file>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
-				<version>2.4.3</version>
+				<version>${maven-shade-plugin.version}</version>
 				<configuration>
 					<createDependencyReducedPom>false</createDependencyReducedPom>
 					<artifactSet>
 						<excludes>
-							<!-- Don't include original swagger-UI as we're including our own 
-								modified version -->
+							<!-- Don't include original swagger-UI as we're including our own modified version -->
 							<exclude>org.webjars:swagger-ui</exclude>
 							<!-- Don't include JUnit as it's for testing only! -->
 							<exclude>junit:junit</exclude>
@@ -304,6 +379,7 @@
 									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
 									<mainClass>org.qortal.controller.Controller</mainClass>
 									<manifestEntries>
+										<Multi-Release>true</Multi-Release>
 										<Class-Path>. ..</Class-Path>
 									</manifestEntries>
 								</transformer>
@@ -312,10 +388,11 @@
 					</execution>
 				</executions>
 			</plugin>
+			<!-- Removed, now use Maven reproducible by default v4.0, IntelliJ v2025.1 and later -->
 			<plugin>
 				<groupId>io.github.zlika</groupId>
 				<artifactId>reproducible-build-maven-plugin</artifactId>
-				<version>0.11</version>
+				<version>${maven-reproducible-build-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>package</phase>
@@ -332,9 +409,9 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>2.22.2</version>
+				<version>${maven-surefire-plugin.version}</version>
 				<configuration>
-					<skipTests>${skipTests}</skipTests>
+					<skipTests>${skipJUnitTests}</skipTests>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -344,46 +421,34 @@
 				<plugin>
 					<groupId>org.eclipse.m2e</groupId>
 					<artifactId>lifecycle-mapping</artifactId>
-					<version>1.0.0</version>
+					<version>${lifecycle-mapping.version}</version>
 					<configuration>
 						<lifecycleMappingMetadata>
 							<pluginExecutions>
 								<pluginExecution>
 									<pluginExecutionFilter>
-										<groupId>
-											org.apache.maven.plugins
-										</groupId>
-										<artifactId>
-											maven-dependency-plugin
-										</artifactId>
-										<versionRange>
-											[2.8,)
-										</versionRange>
+										<groupId>org.apache.maven.plugins</groupId>
+										<artifactId>maven-dependency-plugin</artifactId>
+										<version>${maven-dependency-plugin.version}</version>
 										<goals>
 											<goal>unpack</goal>
 										</goals>
 									</pluginExecutionFilter>
 									<action>
-										<execute></execute>
+										<execute/>
 									</action>
 								</pluginExecution>
 								<pluginExecution>
 									<pluginExecutionFilter>
-										<groupId>
-											com.google.code.maven-replacer-plugin
-										</groupId>
-										<artifactId>
-											replacer
-										</artifactId>
-										<versionRange>
-											[1.5.3,)
-										</versionRange>
+										<groupId>com.google.code.maven-replacer-plugin</groupId>
+										<artifactId>replacer</artifactId>
+										<version>${replacer.version}</version>
 										<goals>
 											<goal>replace</goal>
 										</goals>
 									</pluginExecutionFilter>
 									<action>
-										<execute></execute>
+										<execute/>
 									</action>
 								</pluginExecution>
 							</pluginExecutions>
@@ -410,17 +475,19 @@
 		<dependency>
 			<groupId>org.codehaus.mojo</groupId>
 			<artifactId>build-helper-maven-plugin</artifactId>
-			<version>3.0.0</version>
-			<scope>provided</scope><!-- needed for build, not for runtime -->
+			<version>${maven-build-helper-plugin.version}</version>
+			<scope>provided</scope>
+			<!-- needed for build, not for runtime -->
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/com.github.bohnman/package-info-maven-plugin -->
 		<dependency>
 			<groupId>com.github.bohnman</groupId>
 			<artifactId>package-info-maven-plugin</artifactId>
-			<version>${package-info-maven-plugin.version}</version>
-			<scope>provided</scope><!-- needed for build, not for runtime -->
+			<version>${maven-package-info-plugin.version}</version>
+			<scope>provided</scope>
+			<!-- needed for build, not for runtime -->
 		</dependency>
-		<!-- HSQLDB for repository -->
+		<!-- HSQLDB for repository should use local version with Sealed: false -->
 		<dependency>
 			<groupId>org.hsqldb</groupId>
 			<artifactId>hsqldb</artifactId>
@@ -428,7 +495,7 @@
 		</dependency>
 		<!-- CIYAM AT (automated transactions) -->
 		<dependency>
-			<groupId>org.ciyam</groupId>
+			<groupId>com.github.iceburst</groupId>
 			<artifactId>AT</artifactId>
 			<version>${ciyam-at.version}</version>
 		</dependency>
@@ -446,7 +513,7 @@
 		</dependency>
 		<!-- For Litecoin, etc. support, requires bitcoinj -->
 		<dependency>
-			<groupId>com.github.qortal</groupId>
+			<groupId>com.github.iceburst</groupId>
 			<artifactId>altcoinj</artifactId>
 			<version>${altcoinj.version}</version>
 		</dependency>
@@ -454,12 +521,12 @@
 		<dependency>
 			<groupId>com.googlecode.json-simple</groupId>
 			<artifactId>json-simple</artifactId>
-			<version>1.1.1</version>
+			<version>${json-simple.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.json</groupId>
 			<artifactId>json</artifactId>
-			<version>20210307</version>
+			<version>${json.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
@@ -490,7 +557,7 @@
 		<dependency>
 			<groupId>io.druid</groupId>
 			<artifactId>extendedset</artifactId>
-			<version>0.12.3</version>
+			<version>${extendedset.version}</version>
 			<exclusions>
 				<!-- exclude old versions of jackson-annotations / jackson-core -->
 				<exclusion>
@@ -561,12 +628,12 @@
 		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>javax.servlet-api</artifactId>
-			<version>4.0.1</version>
+			<version>${javax.servlet-api.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>javax.mail</groupId>
 			<artifactId>mail</artifactId>
-			<version>1.5.0-b01</version>
+			<version>${mail.version}</version>
 		</dependency>
 		<!-- Unicode homoglyph utilities -->
 		<dependency>
@@ -635,7 +702,8 @@
 			<artifactId>jersey-hk2</artifactId>
 			<version>${jersey.version}</version>
 			<exclusions>
-				<exclusion><!-- exclude javax.inject-1.jar because other jersey modules include javax.inject v2+ -->
+				<exclusion>
+					<!-- exclude javax.inject-1.jar because other jersey modules include javax.inject v2+ -->
 					<groupId>javax.inject</groupId>
 					<artifactId>javax.inject</artifactId>
 				</exclusion>
@@ -662,7 +730,8 @@
 			<artifactId>swagger-jaxrs2-servlet-initializer</artifactId>
 			<version>${swagger-api.version}</version>
 			<exclusions>
-				<exclusion><!-- excluded because included in swagger-jaxrs2-servlet-initializer -->
+				<exclusion>
+					<!-- excluded because included in swagger-jaxrs2-servlet-initializer -->
 					<groupId>io.swagger.core.v3</groupId>
 					<artifactId>swagger-integration</artifactId>
 				</exclusion>
@@ -678,23 +747,23 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-engine</artifactId>
-			<version>5.3.1</version>
+			<version>${junit-jupiter-engine.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.hamcrest</groupId>
 			<artifactId>hamcrest-library</artifactId>
-			<version>1.3</version>
+			<version>${hamcrest-library.version}</version>
 		</dependency>
 		-->
 		<!-- BouncyCastle for crypto, including TLS secure networking -->
 		<dependency>
 			<groupId>org.bouncycastle</groupId>
-			<artifactId>bcprov-jdk15on</artifactId>
+			<artifactId>bcprov-jdk15to18</artifactId>
 			<version>${bouncycastle.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.bouncycastle</groupId>
-			<artifactId>bctls-jdk15on</artifactId>
+			<artifactId>bctls-jdk15to18</artifactId>
 			<version>${bouncycastle.version}</version>
 		</dependency>
 		<dependency>
@@ -727,5 +796,21 @@
 			<artifactId>protobuf-java</artifactId>
 			<version>${protobuf.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>com.j256.simplemagic</groupId>
+			<artifactId>simplemagic</artifactId>
+			<version>${simplemagic.version}</version>
+		</dependency>
+		<!-- JAXB runtime for WADL support -->
+		<dependency>
+			<groupId>org.glassfish.jaxb</groupId>
+			<artifactId>jaxb-runtime</artifactId>
+			<version>${jaxb-runtime.version}</version>
+		</dependency>
+		<dependency>
+<groupId>org.apache.tika</groupId>
+<artifactId>tika-core</artifactId>
+<version>3.1.0</version> 
+</dependency>
 	</dependencies>
 </project>

src/main/java/cash/z/wallet/sdk/rpc/Service.java

@@ -5290,7 +5290,7 @@ public final class Service {
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(vendor_)) {
         com.google.protobuf.GeneratedMessageV3.writeString(output, 2, vendor_);
       }
-      if (taddrSupport_ != false) {
+      if (taddrSupport_) {
         output.writeBool(3, taddrSupport_);
       }
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(chainName_)) {
@@ -5341,7 +5341,7 @@ public final class Service {
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(vendor_)) {
         size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, vendor_);
       }
-      if (taddrSupport_ != false) {
+      if (taddrSupport_) {
         size += com.google.protobuf.CodedOutputStream
           .computeBoolSize(3, taddrSupport_);
       }
@@ -5729,7 +5729,7 @@ public final class Service {
           vendor_ = other.vendor_;
           onChanged();
         }
-        if (other.getTaddrSupport() != false) {
+        if (other.getTaddrSupport()) {
           setTaddrSupport(other.getTaddrSupport());
         }
         if (!other.getChainName().isEmpty()) {

src/main/java/org/hsqldb/jdbc/HSQLDBPool.java

@@ -1,10 +1,10 @@
 package org.hsqldb.jdbc;
 
+import org.hsqldb.jdbc.pool.JDBCPooledConnection;
+
 import java.sql.Connection;
 import java.sql.SQLException;
 
-import org.hsqldb.jdbc.pool.JDBCPooledConnection;
-
 public class HSQLDBPool extends JDBCPool {
 
 	public HSQLDBPool(int poolSize) {

src/main/java/org/hsqldb/jdbc/HSQLDBPoolMonitored.java

@@ -0,0 +1,173 @@
+package org.hsqldb.jdbc;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.hsqldb.jdbc.pool.JDBCPooledConnection;
+import org.qortal.data.system.DbConnectionInfo;
+import org.qortal.repository.hsqldb.HSQLDBRepositoryFactory;
+
+import javax.sql.ConnectionEvent;
+import javax.sql.PooledConnection;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Class HSQLDBPoolMonitored
+ *
+ * This class uses the same logic as HSQLDBPool. The only difference is it monitors the state of every connection
+ * to the database. This is used for debugging purposes only.
+ */
+public class HSQLDBPoolMonitored extends HSQLDBPool {
+
+	private static final Logger LOGGER = LogManager.getLogger(HSQLDBRepositoryFactory.class);
+
+	private static final String EMPTY = "Empty";
+	private static final String AVAILABLE = "Available";
+	private static final String ALLOCATED = "Allocated";
+
+	private ConcurrentHashMap<Integer, DbConnectionInfo> infoByIndex;
+
+	public HSQLDBPoolMonitored(int poolSize) {
+		super(poolSize);
+
+		this.infoByIndex = new ConcurrentHashMap<>(poolSize);
+	}
+
+	/**
+	 * Tries to retrieve a new connection using the properties that have already been
+	 * set.
+	 *
+	 * @return  a connection to the data source, or null if no spare connections in pool
+	 * @exception SQLException if a database access error occurs
+	 */
+	public Connection tryConnection() throws SQLException {
+		for (int i = 0; i < states.length(); i++) {
+			if (states.compareAndSet(i, RefState.available, RefState.allocated)) {
+				JDBCPooledConnection pooledConnection = connections[i];
+
+				if (pooledConnection == null)
+					// Probably shutdown situation
+					return null;
+
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+				return pooledConnection.getConnection();
+			}
+
+			if (states.compareAndSet(i, RefState.empty, RefState.allocated)) {
+				try {
+					JDBCPooledConnection pooledConnection = (JDBCPooledConnection) source.getPooledConnection();
+
+					if (pooledConnection == null)
+						// Probably shutdown situation
+						return null;
+
+					pooledConnection.addConnectionEventListener(this);
+					pooledConnection.addStatementEventListener(this);
+					connections[i] = pooledConnection;
+
+					infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+					return pooledConnection.getConnection();
+				} catch (SQLException e) {
+					states.set(i, RefState.empty);
+					infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+				}
+			}
+		}
+
+		return null;
+	}
+
+	public Connection getConnection() throws SQLException {
+		int var1 = 300;
+		if (this.source.loginTimeout != 0) {
+			var1 = this.source.loginTimeout * 10;
+		}
+
+		if (this.closed) {
+			throw new SQLException("connection pool is closed");
+		} else {
+			for(int var2 = 0; var2 < var1; ++var2) {
+				for(int var3 = 0; var3 < this.states.length(); ++var3) {
+					if (this.states.compareAndSet(var3, 1, 2)) {
+						infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+						return this.connections[var3].getConnection();
+					}
+
+					if (this.states.compareAndSet(var3, 0, 2)) {
+						try {
+							JDBCPooledConnection var4 = (JDBCPooledConnection)this.source.getPooledConnection();
+							var4.addConnectionEventListener(this);
+							var4.addStatementEventListener(this);
+							this.connections[var3] = var4;
+
+							infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+							return this.connections[var3].getConnection();
+						} catch (SQLException var6) {
+							this.states.set(var3, 0);
+							infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+						}
+					}
+				}
+
+				try {
+					Thread.sleep(100L);
+				} catch (InterruptedException var5) {
+				}
+			}
+
+			throw JDBCUtil.invalidArgument();
+		}
+	}
+
+	public void connectionClosed(ConnectionEvent event) {
+		PooledConnection connection = (PooledConnection) event.getSource();
+
+		for (int i = 0; i < connections.length; i++) {
+			if (connections[i] == connection) {
+				states.set(i, RefState.available);
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), AVAILABLE));
+				break;
+			}
+		}
+	}
+
+	public void connectionErrorOccurred(ConnectionEvent event) {
+		PooledConnection connection = (PooledConnection) event.getSource();
+
+		for (int i = 0; i < connections.length; i++) {
+			if (connections[i] == connection) {
+				states.set(i, RefState.allocated);
+				connections[i] = null;
+				states.set(i, RefState.empty);
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+				break;
+			}
+		}
+	}
+
+	public List<DbConnectionInfo> getDbConnectionsStates() {
+
+		return infoByIndex.values().stream()
+			.sorted(Comparator.comparingLong(DbConnectionInfo::getUpdated))
+			.collect(Collectors.toList());
+	}
+
+	private int findConnectionIndex(ConnectionEvent connectionEvent) {
+		PooledConnection pooledConnection = (PooledConnection) connectionEvent.getSource();
+
+		for(int i = 0; i < this.connections.length; ++i) {
+			if (this.connections[i] == pooledConnection) {
+				return i;
+			}
+		}
+
+		return -1;
+	}
+}

src/main/java/org/qortal/ApplyBootstrap.java

@@ -0,0 +1,227 @@
+package org.qortal;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.api.ApiKey;
+import org.qortal.api.ApiRequest;
+import org.qortal.controller.BootstrapNode;
+import org.qortal.settings.Settings;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.security.Security;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.qortal.controller.BootstrapNode.AGENTLIB_JVM_HOLDER_ARG;
+
+public class ApplyBootstrap {
+
+	static {
+		// This static block will be called before others if using ApplyBootstrap.main()
+
+		// Log into different files for bootstrap - this has to be before LogManger.getLogger() calls
+		System.setProperty("log4j2.filenameTemplate", "log-apply-bootstrap.txt");
+
+		// This must go before any calls to LogManager/Logger
+		System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
+	}
+
+	private static final Logger LOGGER = LogManager.getLogger(ApplyBootstrap.class);
+	private static final String JAR_FILENAME = BootstrapNode.JAR_FILENAME;
+	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
+	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
+
+	private static final long CHECK_INTERVAL = 15 * 1000L; // ms
+	private static final int MAX_ATTEMPTS = 20;
+
+	public static void main(String[] args) {
+		Security.insertProviderAt(new BouncyCastleProvider(), 0);
+		Security.insertProviderAt(new BouncyCastleJsseProvider(), 1);
+
+		// Load/check settings, which potentially sets up blockchain config, etc.
+		if (args.length > 0)
+			Settings.fileInstance(args[0]);
+		else
+			Settings.getInstance();
+
+		LOGGER.info("Applying bootstrap...");
+
+		// Shutdown node using API
+		if (!shutdownNode())
+			return;
+
+		// Delete db
+		deleteDB();
+
+		// Restart node
+		restartNode(args);
+
+		LOGGER.info("Bootstrapping...");
+	}
+
+	private static boolean shutdownNode() {
+		String baseUri = "http://localhost:" + Settings.getInstance().getApiPort() + "/";
+		LOGGER.info(() -> String.format("Shutting down node using API via %s", baseUri));
+
+		// The /admin/stop endpoint requires an API key, which may or may not be already generated
+		boolean apiKeyNewlyGenerated = false;
+		ApiKey apiKey = null;
+		try {
+			apiKey = new ApiKey();
+			if (!apiKey.generated()) {
+				apiKey.generate();
+				apiKeyNewlyGenerated = true;
+				LOGGER.info("Generated API key");
+			}
+		} catch (IOException e) {
+			LOGGER.info("Error loading API key: {}", e.getMessage());
+		}
+
+		// Create GET params
+		Map<String, String> params = new HashMap<>();
+		if (apiKey != null) {
+			params.put("apiKey", apiKey.toString());
+		}
+
+		// Attempt to stop the node
+		int attempt;
+		for (attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+			final int attemptForLogging = attempt;
+			LOGGER.info(() -> String.format("Attempt #%d out of %d to shutdown node", attemptForLogging + 1, MAX_ATTEMPTS));
+			String response = ApiRequest.perform(baseUri + "admin/stop", params);
+			if (response == null) {
+				// No response - consider node shut down
+				if (apiKeyNewlyGenerated) {
+					// API key was newly generated for bootstrapping node, so we need to remove it
+					ApplyBootstrap.removeGeneratedApiKey();
+				}
+				return true;
+			}
+
+			LOGGER.info(() -> String.format("Response from API: %s", response));
+
+			try {
+				Thread.sleep(CHECK_INTERVAL);
+			} catch (InterruptedException e) {
+				// We still need to check...
+				break;
+			}
+		}
+
+		if (apiKeyNewlyGenerated) {
+			// API key was newly generated for bootstrapping node, so we need to remove it
+			ApplyBootstrap.removeGeneratedApiKey();
+		}
+
+		if (attempt == MAX_ATTEMPTS) {
+			LOGGER.error("Failed to shutdown node - giving up");
+			return false;
+		}
+
+		return true;
+	}
+
+	private static void removeGeneratedApiKey() {
+		try {
+			LOGGER.info("Removing newly generated API key...");
+
+			// Delete the API key since it was only generated for bootstrapping node
+			ApiKey apiKey = new ApiKey();
+			apiKey.delete();
+
+		} catch (IOException e) {
+			LOGGER.info("Error loading or deleting API key: {}", e.getMessage());
+		}
+	}
+
+	private static void deleteDB() {
+		// Get the repository path from settings
+		String repositoryPath = Settings.getInstance().getRepositoryPath();
+		LOGGER.debug(String.format("Repository path: %s", repositoryPath));
+
+		try {
+			Path directory = Paths.get(repositoryPath);
+			Files.walkFileTree(directory, new SimpleFileVisitor<Path>() {
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+					Files.delete(file);
+					return FileVisitResult.CONTINUE;
+				}
+
+				@Override
+				public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+					Files.delete(dir);
+					return FileVisitResult.CONTINUE;
+				}
+			});
+		} catch (IOException e) {
+			LOGGER.error("Error deleting DB: {}", e.getMessage());
+		}
+	}
+
+	private static void restartNode(String[] args) {
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
+
+		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+
+		List<String> javaCmd;
+		if (Files.exists(exeLauncher)) {
+			javaCmd = Arrays.asList(exeLauncher.toString());
+		} else {
+			javaCmd = new ArrayList<>();
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Reapply any retained, but disabled, -agentlib JVM arg
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace(AGENTLIB_JVM_HOLDER_ARG, "-agentlib"))
+					.collect(Collectors.toList());
+
+			// Call mainClass in JAR
+			javaCmd.addAll(Arrays.asList("-jar", JAR_FILENAME));
+
+			// Add saved command-line args
+			javaCmd.addAll(Arrays.asList(args));
+		}
+
+		try {
+			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			if (Files.exists(exeLauncher)) {
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
+			}
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node (BAD): %s", e.getMessage()));
+		}
+	}
+}

src/main/java/org/qortal/ApplyRestart.java

@@ -0,0 +1,241 @@
+package org.qortal;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.api.ApiKey;
+import org.qortal.api.ApiRequest;
+import org.qortal.controller.Controller;
+import org.qortal.controller.RestartNode;
+import org.qortal.settings.Settings;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.Security;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
+
+import static org.qortal.controller.RestartNode.AGENTLIB_JVM_HOLDER_ARG;
+
+public class ApplyRestart {
+
+	static {
+		// This static block will be called before others if using ApplyRestart.main()
+
+		// Log into different files for restart node - this has to be before LogManger.getLogger() calls
+		System.setProperty("log4j2.filenameTemplate", "log-apply-restart.txt");
+
+		// This must go before any calls to LogManager/Logger
+		System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
+	}
+
+	private static final Logger LOGGER = LogManager.getLogger(ApplyRestart.class);
+	private static final String JAR_FILENAME = RestartNode.JAR_FILENAME;
+	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
+	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
+
+	private static final long CHECK_INTERVAL = 30 * 1000L; // ms
+	private static final int MAX_ATTEMPTS = 12;
+
+	public static void main(String[] args) {
+		Security.insertProviderAt(new BouncyCastleProvider(), 0);
+		Security.insertProviderAt(new BouncyCastleJsseProvider(), 1);
+
+		// Load/check settings, which potentially sets up blockchain config, etc.
+		if (args.length > 0)
+			Settings.fileInstance(args[0]);
+		else
+			Settings.getInstance();
+
+		LOGGER.info("Applying restart this can take up to 5 minutes...");
+
+		// Shutdown node using API
+		if (!shutdownNode())
+			return;
+
+		try {
+			// Give some time for shutdown
+			TimeUnit.SECONDS.sleep(60);
+
+			// Remove blockchain lock if exist
+			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+			if (blockchainLock.isLocked())
+				blockchainLock.unlock();
+
+			// Remove blockchain lock file if still exist
+			TimeUnit.SECONDS.sleep(60);
+			deleteLock();
+
+			// Restart node
+			TimeUnit.SECONDS.sleep(15);
+			restartNode(args);
+
+			LOGGER.info("Restarting...");
+		} catch (InterruptedException e) {
+			LOGGER.error("Unable to restart", e);
+		}
+	}
+
+	private static boolean shutdownNode() {
+		String baseUri = "http://localhost:" + Settings.getInstance().getApiPort() + "/";
+		LOGGER.debug(() -> String.format("Shutting down node using API via %s", baseUri));
+
+		// The /admin/stop endpoint requires an API key, which may or may not be already generated
+		boolean apiKeyNewlyGenerated = false;
+		ApiKey apiKey = null;
+		try {
+			apiKey = new ApiKey();
+			if (!apiKey.generated()) {
+				apiKey.generate();
+				apiKeyNewlyGenerated = true;
+				LOGGER.info("Generated API key");
+			}
+		} catch (IOException e) {
+			LOGGER.info("Error loading API key: {}", e.getMessage());
+		}
+
+		// Create GET params
+		Map<String, String> params = new HashMap<>();
+		if (apiKey != null) {
+			params.put("apiKey", apiKey.toString());
+		}
+
+		// Attempt to stop the node
+		int attempt;
+		for (attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+			final int attemptForLogging = attempt;
+			LOGGER.info(() -> String.format("Attempt #%d out of %d to shutdown node", attemptForLogging + 1, MAX_ATTEMPTS));
+			String response = ApiRequest.perform(baseUri + "admin/stop", params);
+			if (response == null) {
+				// No response - consider node shut down
+				try {
+					TimeUnit.SECONDS.sleep(30);
+				} catch (InterruptedException e) {
+					throw new RuntimeException(e);
+				}
+
+				if (apiKeyNewlyGenerated) {
+					// API key was newly generated for restarting node, so we need to remove it
+					ApplyRestart.removeGeneratedApiKey();
+				}
+
+				return true;
+			}
+
+			LOGGER.info(() -> String.format("Response from API: %s", response));
+
+			try {
+				Thread.sleep(CHECK_INTERVAL);
+			} catch (InterruptedException e) {
+				// We still need to check...
+				break;
+			}
+		}
+
+		if (apiKeyNewlyGenerated) {
+			// API key was newly generated for restarting node, so we need to remove it
+			ApplyRestart.removeGeneratedApiKey();
+		}
+
+		if (attempt == MAX_ATTEMPTS) {
+			LOGGER.error("Failed to shutdown node - giving up");
+			return false;
+		}
+
+		return true;
+	}
+
+	private static void removeGeneratedApiKey() {
+		try {
+			LOGGER.info("Removing newly generated API key...");
+
+			// Delete the API key since it was only generated for restarting node
+			ApiKey apiKey = new ApiKey();
+			apiKey.delete();
+
+		} catch (IOException e) {
+			LOGGER.error("Error loading or deleting API key: {}", e.getMessage());
+		}
+	}
+
+	private static void deleteLock() {
+		// Get the repository path from settings
+		String repositoryPath = Settings.getInstance().getRepositoryPath();
+		LOGGER.debug(String.format("Repository path is: %s", repositoryPath));
+
+		try {
+			Path root = Paths.get(repositoryPath);
+			File lockFile = new File(root.resolve("blockchain.lck").toUri());
+			LOGGER.debug("Lockfile is: {}", lockFile);
+			FileUtils.forceDelete(FileUtils.getFile(lockFile));
+		} catch (IOException e) {
+			LOGGER.debug("Error deleting blockchain lock file: {}", e.getMessage());
+		}
+	}
+
+	private static void restartNode(String[] args) {
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
+
+		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+
+		List<String> javaCmd;
+		if (Files.exists(exeLauncher)) {
+			javaCmd = List.of(exeLauncher.toString());
+		} else {
+			javaCmd = new ArrayList<>();
+
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Reapply any retained, but disabled, -agentlib JVM arg
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace(AGENTLIB_JVM_HOLDER_ARG, "-agentlib"))
+					.collect(Collectors.toList());
+
+			// Call mainClass in JAR
+			javaCmd.addAll(Arrays.asList("-jar", JAR_FILENAME));
+
+			// Add saved command-line args
+			javaCmd.addAll(Arrays.asList(args));
+		}
+
+		try {
+			LOGGER.debug(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			if (Files.exists(exeLauncher)) {
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
+			}
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node (BAD): %s", e.getMessage()));
+		}
+	}
+}

src/main/java/org/qortal/ApplyUpdate.java

@@ -1,5 +1,14 @@
 package org.qortal;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.api.ApiKey;
+import org.qortal.api.ApiRequest;
+import org.qortal.controller.AutoUpdate;
+import org.qortal.settings.Settings;
+
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.nio.file.Files;
@@ -10,15 +19,6 @@ import java.security.Security;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.bouncycastle.jce.provider.BouncyCastleProvider;
-import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
-import org.qortal.api.ApiKey;
-import org.qortal.api.ApiRequest;
-import org.qortal.controller.AutoUpdate;
-import org.qortal.settings.Settings;
-
 import static org.qortal.controller.AutoUpdate.AGENTLIB_JVM_HOLDER_ARG;
 
 public class ApplyUpdate {
@@ -38,7 +38,7 @@ public class ApplyUpdate {
 	private static final String NEW_JAR_FILENAME = AutoUpdate.NEW_JAR_FILENAME;
 	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
 	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
-	private static final String JAVA_TOOL_OPTIONS_VALUE = "-XX:MaxRAMFraction=4";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
 
 	private static final long CHECK_INTERVAL = 30 * 1000L; // ms
 	private static final int MAX_ATTEMPTS = 12;
@@ -139,7 +139,7 @@ public class ApplyUpdate {
 			apiKey.delete();
 
 		} catch (IOException e) {
-			LOGGER.info("Error loading or deleting API key: {}", e.getMessage());
+			LOGGER.error("Error loading or deleting API key: {}", e.getMessage());
 		}
 	}
 
@@ -181,13 +181,13 @@ public class ApplyUpdate {
 
 	private static void restartNode(String[] args) {
 		String javaHome = System.getProperty("java.home");
-		LOGGER.info(() -> String.format("Java home: %s", javaHome));
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
 
 		Path javaBinary = Paths.get(javaHome, "bin", "java");
-		LOGGER.info(() -> String.format("Java binary: %s", javaBinary));
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
 
 		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
-		LOGGER.info(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
 
 		List<String> javaCmd;
 		if (Files.exists(exeLauncher)) {
@@ -213,12 +213,12 @@ public class ApplyUpdate {
 		}
 
 		try {
-			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+			LOGGER.debug(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
 
 			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
 
 			if (Files.exists(exeLauncher)) {
-				LOGGER.info(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
 				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
 			}
 

src/main/java/org/qortal/RepositoryMaintenance.java

@@ -1,8 +1,5 @@
 package org.qortal;
 
-import java.security.Security;
-import java.util.concurrent.TimeoutException;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
@@ -15,6 +12,9 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.repository.hsqldb.HSQLDBRepositoryFactory;
 import org.qortal.settings.Settings;
 
+import java.security.Security;
+import java.util.concurrent.TimeoutException;
+
 public class RepositoryMaintenance {
 
 	static {

src/main/java/org/qortal/XorUpdate.java

@@ -1,5 +1,7 @@
 package org.qortal;
 
+import org.qortal.controller.AutoUpdate;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -7,8 +9,6 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
-import org.qortal.controller.AutoUpdate;
-
 public class XorUpdate {
 
 	private static final byte XOR_VALUE = AutoUpdate.XOR_VALUE;

src/main/java/org/qortal/account/Account.java

@@ -1,21 +1,33 @@
 package org.qortal.account;
 
-import static org.qortal.utils.Amounts.prettyAmount;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.qortal.api.resource.TransactionsResource;
 import org.qortal.block.BlockChain;
 import org.qortal.controller.LiteNode;
 import org.qortal.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.RewardShareData;
+import org.qortal.data.naming.NameData;
+import org.qortal.data.transaction.TransactionData;
 import org.qortal.repository.DataException;
+import org.qortal.repository.GroupRepository;
+import org.qortal.repository.NameRepository;
 import org.qortal.repository.Repository;
 import org.qortal.settings.Settings;
 import org.qortal.utils.Base58;
+import org.qortal.utils.Groups;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.qortal.utils.Amounts.prettyAmount;
 
 @XmlAccessorType(XmlAccessType.NONE) // Stops JAX-RS errors when unmarshalling blockchain config
 public class Account {
@@ -193,27 +205,85 @@ public class Account {
 
 	/** Returns whether account can be considered a "minting account".
 	 * <p>
-	 * To be considered a "minting account", the account needs to pass at least one of these tests:<br>
+	 * To be considered a "minting account", the account needs to pass some of these tests:<br>
 	 * <ul>
 	 * <li>account's level is at least <tt>minAccountLevelToMint</tt> from blockchain config</li>
-	 * <li>account has 'founder' flag set</li>
+	 * <li>account's address has registered a name</li>
+	 * <li>account's address is a member of the minter group</li>
 	 * </ul>
-	 * 
+	 *
+	 * @param isGroupValidated true if this account has already been validated for MINTER Group membership
 	 * @return true if account can be considered "minting account"
 	 * @throws DataException
 	 */
-	public boolean canMint() throws DataException {
+	public boolean canMint(boolean isGroupValidated) throws DataException {
 		AccountData accountData = this.repository.getAccountRepository().getAccount(this.address);
-		if (accountData == null)
-			return false;
+		NameRepository nameRepository = this.repository.getNameRepository();
+		GroupRepository groupRepository = this.repository.getGroupRepository();
+		String myAddress = accountData.getAddress();
 
-		Integer level = accountData.getLevel();
-		if (level != null && level >= BlockChain.getInstance().getMinAccountLevelToMint())
-			return true;
+		int blockchainHeight = this.repository.getBlockRepository().getBlockchainHeight();
 
-		// Founders can always mint, unless they have a penalty
-		if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
-			return true;
+		int levelToMint;
+
+		if( blockchainHeight >= BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() ) {
+			levelToMint = 0;
+		}
+		else {
+			levelToMint = BlockChain.getInstance().getMinAccountLevelToMint();
+		}
+
+		int level = accountData.getLevel();
+		List<Integer> groupIdsToMint = Groups.getGroupIdsToMint( BlockChain.getInstance(), blockchainHeight );
+		int nameCheckHeight = BlockChain.getInstance().getOnlyMintWithNameHeight();
+		int groupCheckHeight = BlockChain.getInstance().getGroupMemberCheckHeight();
+		int removeNameCheckHeight = BlockChain.getInstance().getRemoveOnlyMintWithNameHeight();
+
+		// Can only mint if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		if (blockchainHeight < nameCheckHeight) {
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0;
+			} else {
+				return level >= levelToMint;
+			}
+		}
+
+		// Can only mint on onlyMintWithNameHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address has registered a name
+		if (blockchainHeight >= nameCheckHeight && blockchainHeight < groupCheckHeight) {
+			List<NameData> myName = nameRepository.getNamesByOwner(myAddress);
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && !myName.isEmpty();
+			} else {
+				return level >= levelToMint && !myName.isEmpty();
+			}
+		}
+
+		// Can only mint on groupMemberCheckHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address has registered a name
+		// Account's address is a member of the minter group
+		if (blockchainHeight >= groupCheckHeight && blockchainHeight < removeNameCheckHeight) {
+			List<NameData> myName = nameRepository.getNamesByOwner(myAddress);
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && !myName.isEmpty() && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			} else {
+				return level >= levelToMint && !myName.isEmpty() && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			}
+		}
+
+		// Can only mint on removeOnlyMintWithNameHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address is a member of the minter group
+		if (blockchainHeight >= removeNameCheckHeight) {
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			} else {
+				return level >= levelToMint && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			}
+		}
 
 		return false;
 	}
@@ -228,7 +298,6 @@ public class Account {
 		return this.repository.getAccountRepository().getBlocksMintedPenaltyCount(this.address);
 	}
 
-
 	/** Returns whether account can build reward-shares.
 	 * <p>
 	 * To be able to create reward-shares, the account needs to pass at least one of these tests:<br>
@@ -242,6 +311,7 @@ public class Account {
 	 */
 	public boolean canRewardShare() throws DataException {
 		AccountData accountData = this.repository.getAccountRepository().getAccount(this.address);
+
 		if (accountData == null)
 			return false;
 
@@ -252,6 +322,9 @@ public class Account {
 		if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
 			return true;
 
+		if( this.repository.getBlockRepository().getBlockchainHeight() >= BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() )
+			return true;
+
 		return false;
 	}
 
@@ -295,10 +368,164 @@ public class Account {
 	}
 
 	/**
-	 * Returns 'effective' minting level, or zero if reward-share does not exist.
+	 * Get Primary Name
+	 *
+	 * @return the primary name for this address if present, otherwise empty
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> getPrimaryName() throws DataException {
+
+		return this.repository.getNameRepository().getPrimaryName(this.address);
+	}
+
+	/**
+	 * Remove Primary Name
+	 *
+	 * @throws DataException
+	 */
+	public void removePrimaryName() throws DataException {
+		this.repository.getNameRepository().removePrimaryName(this.address);
+	}
+
+	/**
+	 * Reset Primary Name
+	 *
+	 * Set primary name based on the names (and their history) this account owns.
+	 *
+	 * @param confirmationStatus the status of the transactions for the determining the primary name
+	 *
+	 * @return the primary name, empty if their isn't one
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> resetPrimaryName(TransactionsResource.ConfirmationStatus confirmationStatus) throws DataException {
+		Optional<String> primaryName = determinePrimaryName(confirmationStatus);
+
+		if(primaryName.isPresent()) {
+			return setPrimaryName(primaryName.get());
+		}
+		else {
+			return primaryName;
+		}
+	}
+
+	/**
+	 * Determine Primary Name
+	 *
+	 * Determine primary name based on a list of registered names.
+	 *
+	 * @param confirmationStatus the status of the transactions for this determination
+	 *
+	 * @return the primary name, empty if there is no primary name
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> determinePrimaryName(TransactionsResource.ConfirmationStatus confirmationStatus) throws DataException {
+
+		// all registered names for the owner
+		List<NameData> names = this.repository.getNameRepository().getNamesByOwner(this.address);
+
+		Optional<String> primaryName;
+
+		// if no registered names, the no primary name possible
+		if (names.isEmpty()) {
+			primaryName = Optional.empty();
+		}
+		// if names
+		else {
+			// if one name, then that is the primary name
+			if (names.size() == 1) {
+				primaryName = Optional.of( names.get(0).getName() );
+			}
+			// if more than one name, then seek the earliest name acquisition that was never released
+			else {
+				Map<String, TransactionData> txByName = new HashMap<>(names.size());
+
+				// for each name, get the latest transaction
+				for (NameData nameData : names) {
+
+					// since the name is currently registered to the owner,
+					// we assume the latest transaction involving this name was the transaction that the acquired
+					// name through registration, purchase or update
+					Optional<TransactionData> latestTransaction
+							= this.repository
+							.getTransactionRepository()
+							.getTransactionsInvolvingName(
+									nameData.getName(),
+									confirmationStatus
+							)
+							.stream()
+							.sorted(Comparator.comparing(
+									TransactionData::getTimestamp).reversed()
+							)
+							.findFirst(); // first is the last, since it was reversed
+
+					// if there is a latest transaction, expected for all registered names
+					if (latestTransaction.isPresent()) {
+						txByName.put(nameData.getName(), latestTransaction.get());
+					}
+					// if there is no latest transaction, then
+					else {
+						LOGGER.warn("No matching transaction for name: " + nameData.getName());
+					}
+				}
+
+				// get the first name aqcuistion for this address
+				Optional<Map.Entry<String, TransactionData>> firstNameEntry
+						= txByName.entrySet().stream().sorted(Comparator.comparing(entry -> entry.getValue().getTimestamp())).findFirst();
+
+				// if their is a name acquisition, then the first one is the primary name
+				if (firstNameEntry.isPresent()) {
+					primaryName = Optional.of( firstNameEntry.get().getKey() );
+				}
+				// if there is no nameacquistion, then there is no primary name
+				else {
+					primaryName =  Optional.empty();
+				}
+			}
+		}
+		return primaryName;
+	}
+
+	/**
+	 * Set Primary Name
+	 *
+	 * @param primaryName the primary to set to this address
+	 *
+	 * @return the primary name if successful, empty if unsuccessful
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> setPrimaryName( String primaryName ) throws DataException {
+		int changed = this.repository.getNameRepository().setPrimaryName(this.address, primaryName);
+
+		return changed > 0 ? Optional.of(primaryName) : Optional.empty();
+	}
+
+	/**
+	 * Returns reward-share minting address, or unknown if reward-share does not exist.
 	 * 
 	 * @param repository
 	 * @param rewardSharePublicKey
+	 * @return address or unknown
+	 * @throws DataException
+	 */
+	public static String getRewardShareMintingAddress(Repository repository, byte[] rewardSharePublicKey) throws DataException {
+		// Find actual minter address
+		RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(rewardSharePublicKey);
+
+		if (rewardShareData == null)
+			return "Unknown";
+
+		return rewardShareData.getMinter();
+	}
+
+	/**
+	 * Returns 'effective' minting level, or zero if reward-share does not exist.
+	 *
+	 * @param repository
+	 * @param rewardSharePublicKey
 	 * @return 0+
 	 * @throws DataException
 	 */
@@ -311,6 +538,7 @@ public class Account {
 		Account rewardShareMinter = new Account(repository, rewardShareData.getMinter());
 		return rewardShareMinter.getEffectiveMintingLevel();
 	}
+
 	/**
 	 * Returns 'effective' minting level, with a fix for the zero level.
 	 * <p>

src/main/java/org/qortal/account/AccountRefCache.java

@@ -1,15 +1,15 @@
 package org.qortal.account;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.function.BinaryOperator;
-
 import org.qortal.data.account.AccountData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.utils.Pair;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.BinaryOperator;
+
 /**
  * Account lastReference caching
  * <p>

src/main/java/org/qortal/account/PublicKeyAccount.java

@@ -1,17 +1,41 @@
 package org.qortal.account;
 
+import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
+import org.bouncycastle.crypto.params.Ed25519KeyGenerationParameters;
 import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountData;
 import org.qortal.repository.Repository;
 
+import java.security.SecureRandom;
+
 public class PublicKeyAccount extends Account {
 
 	protected final byte[] publicKey;
 	protected final Ed25519PublicKeyParameters edPublicKeyParams;
 
+	/** <p>Constructor for generating a PublicKeyAccount</p>
+	 *
+	 * @param repository Block Chain
+	 * @param publicKey 32 byte Public Key
+	 * @since v4.7.3
+	 */
 	public PublicKeyAccount(Repository repository, byte[] publicKey) {
-		this(repository, new Ed25519PublicKeyParameters(publicKey, 0));
+		super(repository, Crypto.toAddress(publicKey));
+
+		Ed25519PublicKeyParameters t = null;
+		try {
+			t = new Ed25519PublicKeyParameters(publicKey, 0);
+		} catch (Exception e) {
+			var gen = new Ed25519KeyPairGenerator();
+			gen.init(new Ed25519KeyGenerationParameters(new SecureRandom()));
+			var keyPair = gen.generateKeyPair();
+			t = (Ed25519PublicKeyParameters) keyPair.getPublic();
+		} finally {
+			this.edPublicKeyParams = t;
+		}
+
+		this.publicKey = publicKey;
 	}
 
 	protected PublicKeyAccount(Repository repository, Ed25519PublicKeyParameters edPublicKeyParams) {

src/main/java/org/qortal/account/SelfSponsorshipAlgoV1.java

@@ -340,7 +340,7 @@ public class SelfSponsorshipAlgoV1 {
             return true;
         }
         transactionDataList.removeIf(t -> t.getTimestamp() >= this.snapshotTimestamp);
-        return transactionDataList.size() == 0;
+        return transactionDataList.isEmpty();
     }
 
     private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
@@ -363,5 +363,4 @@ public class SelfSponsorshipAlgoV1 {
 
         return transactionDataList;
     }
-
-}
+}

src/main/java/org/qortal/account/SelfSponsorshipAlgoV2.java

@@ -0,0 +1,249 @@
+package org.qortal.account;
+
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.asset.Asset;
+import org.qortal.block.BlockChain;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.transaction.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import java.util.*;
+
+public class SelfSponsorshipAlgoV2 {
+
+    private final long snapshotTimestampV1 = BlockChain.getInstance().getSelfSponsorshipAlgoV1SnapshotTimestamp();
+    private final long snapshotTimestampV2 = BlockChain.getInstance().getSelfSponsorshipAlgoV2SnapshotTimestamp();
+    private final long referenceTimestamp = BlockChain.getInstance().getReferenceTimestampBlock();
+
+    private final boolean override;
+    private final Repository repository;
+    private final String address;
+
+    private int recentAssetSendCount  = 0;
+    private int recentSponsorshipCount = 0;
+
+    private final Set<String> assetAddresses = new LinkedHashSet<>();
+    private final Set<String> penaltyAddresses = new LinkedHashSet<>();
+    private final Set<String> sponsorAddresses = new LinkedHashSet<>();
+
+    private List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+    private List<TransferAssetTransactionData> transferAssetForAddress = new ArrayList<>();
+
+    public SelfSponsorshipAlgoV2(Repository repository, String address, boolean override) {
+        this.repository = repository;
+        this.address = address;
+        this.override = override;
+    }
+
+    public String getAddress() {
+        return this.address;
+    }
+
+    public Set<String> getPenaltyAddresses() {
+        return this.penaltyAddresses;
+    }
+
+    public void run() throws DataException {
+        if (!override) {
+            this.getAccountPrivs(this.address);
+        }
+
+        if (override) {
+            this.fetchTransferAssetForAddress(this.address);
+            this.findRecentAssetSendCount();
+
+            if (this.recentAssetSendCount >= 6) {
+                this.penaltyAddresses.add(this.address);
+                this.penaltyAddresses.addAll(this.assetAddresses);
+            }
+        }
+    }
+
+    private void getAccountPrivs(String address) throws DataException {
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        transferPrivsTransactions.removeIf(t -> t.getTimestamp() > this.referenceTimestamp || accountData.getAddress().equals(t.getRecipient()));
+
+        if (transferPrivsTransactions.isEmpty()) {
+            // Nothing to do
+            return;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            this.penaltyAddresses.add(transferPrivsTransactionData.getRecipient());
+            this.fetchSponsorshipRewardShares(transferPrivsTransactionData.getRecipient());
+            this.findRecentSponsorshipCount();
+
+            if (this.recentSponsorshipCount >= 1) {
+                this.penaltyAddresses.addAll(this.sponsorAddresses);
+            }
+
+            String newAddress = this.getDestinationAccount(transferPrivsTransactionData.getRecipient());
+
+            while (newAddress != null) {
+                // Found destination account
+                this.penaltyAddresses.add(newAddress);
+                this.fetchSponsorshipRewardShares(newAddress);
+                this.findRecentSponsorshipCount();
+
+                if (this.recentSponsorshipCount >= 1) {
+                    this.penaltyAddresses.addAll(this.sponsorAddresses);
+                }
+
+                newAddress = this.getDestinationAccount(newAddress);
+            }
+        }
+    }
+
+    private String getDestinationAccount(String address) throws DataException {
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        transferPrivsTransactions.removeIf(t -> t.getTimestamp() > this.referenceTimestamp || accountData.getAddress().equals(t.getRecipient()));
+
+        if (transferPrivsTransactions.isEmpty()) {
+            return null;
+        }
+
+        if (accountData == null) {
+            return null;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            if (Arrays.equals(transferPrivsTransactionData.getSenderPublicKey(), accountData.getPublicKey())) {
+                return transferPrivsTransactionData.getRecipient();
+            }
+        }
+
+        return null;
+    }
+
+    private void fetchSponsorshipRewardShares(String address) throws DataException {
+        AccountData accountDataRs = this.repository.getAccountRepository().getAccount(address);
+        List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.REWARD_SHARE);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, address, false);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.REWARD_SHARE) {
+                continue;
+            }
+
+            RewardShareTransactionData rewardShareTransactionData = (RewardShareTransactionData) transactionData;
+
+            // Skip removals
+            if (rewardShareTransactionData.getSharePercent() < 0) {
+                continue;
+            }
+
+            // Skip if not sponsored by this account
+            if (!Arrays.equals(rewardShareTransactionData.getCreatorPublicKey(), accountDataRs.getPublicKey())) {
+                continue;
+            }
+
+            // Skip self shares
+            if (Objects.equals(rewardShareTransactionData.getRecipient(), address)) {
+                continue;
+            }
+
+            boolean duplicateFound = false;
+            for (RewardShareTransactionData existingRewardShare : sponsorshipRewardShares) {
+                if (Objects.equals(existingRewardShare.getRecipient(), rewardShareTransactionData.getRecipient())) {
+                    // Duplicate
+                    duplicateFound = true;
+                    break;
+                }
+            }
+
+            if (!duplicateFound) {
+                sponsorshipRewardShares.add(rewardShareTransactionData);
+                this.sponsorAddresses.add(rewardShareTransactionData.getRecipient());
+            }
+        }
+
+        this.sponsorshipRewardShares = sponsorshipRewardShares;
+    }
+
+    private void fetchTransferAssetForAddress(String address) throws DataException {
+        List<TransferAssetTransactionData> transferAssetForAddress = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.TRANSFER_ASSET);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, address, false);
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV2);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.TRANSFER_ASSET) {
+                continue;
+            }
+
+            TransferAssetTransactionData transferAssetTransactionData = (TransferAssetTransactionData) transactionData;
+
+            if (transferAssetTransactionData.getAssetId() == Asset.QORT) {
+                if (!Objects.equals(transferAssetTransactionData.getRecipient(), address)) {
+                    // Outgoing transfer asset for this account
+                    transferAssetForAddress.add(transferAssetTransactionData);
+                    this.assetAddresses.add(transferAssetTransactionData.getRecipient());
+                }
+            }
+        }
+
+        this.transferAssetForAddress = transferAssetForAddress;
+    }
+
+    private void findRecentSponsorshipCount() {
+        int recentSponsorshipCount = 0;
+
+        for (RewardShareTransactionData rewardShare : sponsorshipRewardShares) {
+            if (rewardShare.getTimestamp() >= this.snapshotTimestampV1) {
+                recentSponsorshipCount++;
+            }
+        }
+
+        this.recentSponsorshipCount = recentSponsorshipCount;
+    }
+
+    private void findRecentAssetSendCount() {
+        int recentAssetSendCount = 0;
+
+        for (TransferAssetTransactionData assetSend : transferAssetForAddress) {
+            if (assetSend.getTimestamp() >= this.snapshotTimestampV1) {
+                recentAssetSendCount++;
+            }
+        }
+
+        this.recentAssetSendCount = recentAssetSendCount;
+    }
+
+    private List<TransactionData> fetchTransferPrivsForAddress(String address) throws DataException {
+        return fetchTransactions(repository,
+                List.of(TransactionType.TRANSFER_PRIVS),
+                address, true);
+    }
+
+    private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
+        // Fetch all relevant transactions for this account
+        List<byte[]> signatures = repository.getTransactionRepository()
+                .getSignaturesMatchingCriteria(null, null, null, txTypes,
+                        null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED,
+                        null, null, reverse);
+
+        List<TransactionData> transactionDataList = new ArrayList<>();
+
+        for (byte[] signature : signatures) {
+            // Fetch transaction data
+            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+            if (transactionData == null) {
+                continue;
+            }
+            transactionDataList.add(transactionData);
+        }
+
+        return transactionDataList;
+    }
+}

src/main/java/org/qortal/account/SelfSponsorshipAlgoV3.java

@@ -0,0 +1,370 @@
+package org.qortal.account;
+
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.asset.Asset;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.naming.NameData;
+import org.qortal.data.transaction.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SelfSponsorshipAlgoV3 {
+
+    private final Repository repository;
+    private final String address;
+    private final AccountData accountData;
+    private final long snapshotTimestampV1;
+    private final long snapshotTimestampV3;
+    private final boolean override;
+
+    private int registeredNameCount = 0;
+    private int suspiciousCount = 0;
+    private int suspiciousPercent = 0;
+    private int consolidationCount = 0;
+    private int bulkIssuanceCount = 0;
+    private int recentSponsorshipCount = 0;
+
+    private List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+    private final Map<String, List<TransactionData>> paymentsByAddress = new HashMap<>();
+    private final Set<String> sponsees = new LinkedHashSet<>();
+    private Set<String> consolidatedAddresses = new LinkedHashSet<>();
+    private final Set<String> zeroTransactionAddreses = new LinkedHashSet<>();
+    private final Set<String> penaltyAddresses = new LinkedHashSet<>();
+
+    public SelfSponsorshipAlgoV3(Repository repository, String address, long snapshotTimestampV1, long snapshotTimestampV3, boolean override) throws DataException {
+        this.repository = repository;
+        this.address = address;
+        this.accountData = this.repository.getAccountRepository().getAccount(this.address);
+        this.snapshotTimestampV1 = snapshotTimestampV1;
+        this.snapshotTimestampV3 = snapshotTimestampV3;
+        this.override = override;
+    }
+
+    public String getAddress() {
+        return this.address;
+    }
+
+    public Set<String> getPenaltyAddresses() {
+        return this.penaltyAddresses;
+    }
+
+
+    public void run() throws DataException {
+        if (this.accountData == null) {
+            // Nothing to do
+            return;
+        }
+
+        this.fetchSponsorshipRewardShares();
+        if (this.sponsorshipRewardShares.isEmpty()) {
+            // Nothing to do
+            return;
+        }
+
+        this.findConsolidatedRewards();
+        this.findBulkIssuance();
+        this.findRegisteredNameCount();
+        this.findRecentSponsorshipCount();
+
+        int score = this.calculateScore();
+        if (score <= 0 && !override) {
+            return;
+        }
+
+        String newAddress = this.getDestinationAccount(this.address);
+        while (newAddress != null) {
+            // Found destination account
+            this.penaltyAddresses.add(newAddress);
+
+            // Run algo for this address, but in "override" mode because it has already been flagged
+            SelfSponsorshipAlgoV3 algoV3 = new SelfSponsorshipAlgoV3(this.repository, newAddress, this.snapshotTimestampV1, this.snapshotTimestampV3, true);
+            algoV3.run();
+            this.penaltyAddresses.addAll(algoV3.getPenaltyAddresses());
+
+            newAddress = this.getDestinationAccount(newAddress);
+        }
+
+        this.penaltyAddresses.add(this.address);
+
+        if (this.override || this.recentSponsorshipCount < 20) {
+            this.penaltyAddresses.addAll(this.consolidatedAddresses);
+            this.penaltyAddresses.addAll(this.zeroTransactionAddreses);
+        }
+        else {
+            this.penaltyAddresses.addAll(this.sponsees);
+        }
+    }
+
+    private String getDestinationAccount(String address) throws DataException {
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        if (transferPrivsTransactions.isEmpty()) {
+            // No TRANSFER_PRIVS transactions for this address
+            return null;
+        }
+
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        if (accountData == null) {
+            return null;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            if (Arrays.equals(transferPrivsTransactionData.getSenderPublicKey(), accountData.getPublicKey())) {
+                return transferPrivsTransactionData.getRecipient();
+            }
+        }
+
+        return null;
+    }
+
+    private void findConsolidatedRewards() throws DataException {
+        List<String> sponseesThatSentRewards = new ArrayList<>();
+        Map<String, Integer> paymentRecipients = new HashMap<>();
+
+        // Collect outgoing payments of each sponsee
+        for (String sponseeAddress : this.sponsees) {
+
+            // Firstly fetch all payments for address, since the functions below depend on this data
+            this.fetchPaymentsForAddress(sponseeAddress);
+
+            // Check if the address has zero relevant transactions
+            if (this.hasZeroTransactions(sponseeAddress)) {
+                this.zeroTransactionAddreses.add(sponseeAddress);
+            }
+
+            // Get payment recipients
+            List<String> allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+            if (allPaymentRecipients.isEmpty()) {
+                continue;
+            }
+            sponseesThatSentRewards.add(sponseeAddress);
+
+            List<String> addressesPaidByThisSponsee = new ArrayList<>();
+            for (String paymentRecipient : allPaymentRecipients) {
+                if (addressesPaidByThisSponsee.contains(paymentRecipient)) {
+                    // We already tracked this association - don't allow multiple to stack up
+                    continue;
+                }
+                addressesPaidByThisSponsee.add(paymentRecipient);
+
+                // Increment count for this recipient, or initialize to 1 if not present
+                if (paymentRecipients.computeIfPresent(paymentRecipient, (k, v) -> v + 1) == null) {
+                    paymentRecipients.put(paymentRecipient, 1);
+                }
+            }
+
+        }
+
+        // Exclude addresses with a low number of payments
+        Map<String, Integer> filteredPaymentRecipients = paymentRecipients.entrySet().stream()
+                .filter(p -> p.getValue() != null && p.getValue() >= 10)
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        // Now check how many sponsees have sent to this subset of addresses
+        Map<String, Integer> sponseesThatConsolidatedRewards = new HashMap<>();
+        for (String sponseeAddress : sponseesThatSentRewards) {
+            List<String> allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+            // Remove any that aren't to one of the flagged recipients (i.e. consolidation)
+            allPaymentRecipients.removeIf(r -> !filteredPaymentRecipients.containsKey(r));
+
+            int count = allPaymentRecipients.size();
+            if (count == 0) {
+                continue;
+            }
+            if (sponseesThatConsolidatedRewards.computeIfPresent(sponseeAddress, (k, v) -> v + count) == null) {
+                sponseesThatConsolidatedRewards.put(sponseeAddress, count);
+            }
+        }
+
+        // Remove sponsees that have only sent a low number of payments to the filtered addresses
+        Map<String, Integer> filteredSponseesThatConsolidatedRewards = sponseesThatConsolidatedRewards.entrySet().stream()
+                .filter(p -> p.getValue() != null && p.getValue() >= 2)
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        this.consolidationCount = sponseesThatConsolidatedRewards.size();
+        this.consolidatedAddresses = new LinkedHashSet<>(filteredSponseesThatConsolidatedRewards.keySet());
+        this.suspiciousCount = this.consolidationCount + this.zeroTransactionAddreses.size();
+        this.suspiciousPercent = (int)(this.suspiciousCount / (float) this.sponsees.size() * 100);
+    }
+
+    private void findBulkIssuance() {
+        Long lastTimestamp = null;
+        for (RewardShareTransactionData rewardShareTransactionData : sponsorshipRewardShares) {
+            long timestamp = rewardShareTransactionData.getTimestamp();
+            if (timestamp >= this.snapshotTimestampV3) {
+                continue;
+            }
+
+            if (lastTimestamp != null) {
+                if (timestamp - lastTimestamp < 3*60*1000L) {
+                    this.bulkIssuanceCount++;
+                }
+            }
+            lastTimestamp = timestamp;
+        }
+    }
+
+    private void findRegisteredNameCount() throws DataException {
+        int registeredNameCount = 0;
+        for (String sponseeAddress : sponsees) {
+            List<NameData> names = repository.getNameRepository().getNamesByOwner(sponseeAddress);
+            for (NameData name : names) {
+                if (name.getRegistered() < this.snapshotTimestampV3) {
+                    registeredNameCount++;
+                    break;
+                }
+            }
+        }
+        this.registeredNameCount = registeredNameCount;
+    }
+
+    private void findRecentSponsorshipCount() {
+        int recentSponsorshipCount = 0;
+        for (RewardShareTransactionData rewardShare : sponsorshipRewardShares) {
+            if (rewardShare.getTimestamp() >= this.snapshotTimestampV1) {
+                recentSponsorshipCount++;
+            }
+        }
+        this.recentSponsorshipCount = recentSponsorshipCount;
+    }
+
+    private int calculateScore() {
+        final int suspiciousMultiplier = (this.suspiciousCount >= 100) ? this.suspiciousPercent : 1;
+        final int nameMultiplier = (this.sponsees.size() >= 25 && this.registeredNameCount <= 1) ? 21 :
+            (this.sponsees.size() >= 15 && this.registeredNameCount <= 1) ? 11 :
+                (this.sponsees.size() >= 5 && this.registeredNameCount <= 1) ? 5 : 1;
+        final int consolidationMultiplier = Math.max(this.consolidationCount, 1);
+        final int bulkIssuanceMultiplier = Math.max(this.bulkIssuanceCount / 2, 1);
+        final int offset = 20;
+        return suspiciousMultiplier * nameMultiplier * consolidationMultiplier * bulkIssuanceMultiplier - offset;
+    }
+
+    private void fetchSponsorshipRewardShares() throws DataException {
+        List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.REWARD_SHARE);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, this.address, false);
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.REWARD_SHARE) {
+                continue;
+            }
+
+            RewardShareTransactionData rewardShareTransactionData = (RewardShareTransactionData) transactionData;
+
+            // Skip removals
+            if (rewardShareTransactionData.getSharePercent() < 0) {
+                continue;
+            }
+
+            // Skip if not sponsored by this account
+            if (!Arrays.equals(rewardShareTransactionData.getCreatorPublicKey(), accountData.getPublicKey())) {
+                continue;
+            }
+
+            // Skip self shares
+            if (Objects.equals(rewardShareTransactionData.getRecipient(), this.address)) {
+                continue;
+            }
+
+            boolean duplicateFound = false;
+            for (RewardShareTransactionData existingRewardShare : sponsorshipRewardShares) {
+                if (Objects.equals(existingRewardShare.getRecipient(), rewardShareTransactionData.getRecipient())) {
+                    // Duplicate
+                    duplicateFound = true;
+                    break;
+                }
+            }
+            if (!duplicateFound) {
+                sponsorshipRewardShares.add(rewardShareTransactionData);
+                this.sponsees.add(rewardShareTransactionData.getRecipient());
+            }
+        }
+
+        this.sponsorshipRewardShares = sponsorshipRewardShares;
+    }
+
+    private List<TransactionData> fetchTransferPrivsForAddress(String address) throws DataException {
+        return fetchTransactions(repository,
+                List.of(TransactionType.TRANSFER_PRIVS),
+                address, true);
+    }
+
+    private void fetchPaymentsForAddress(String address) throws DataException {
+        List<TransactionData> payments = fetchTransactions(repository,
+                Arrays.asList(TransactionType.PAYMENT, TransactionType.TRANSFER_ASSET),
+                address, false);
+        this.paymentsByAddress.put(address, payments);
+    }
+
+    private List<String> fetchOutgoingPaymentRecipientsForAddress(String address) {
+        List<String> outgoingPaymentRecipients = new ArrayList<>();
+
+        List<TransactionData> transactionDataList = this.paymentsByAddress.get(address);
+        if (transactionDataList == null) transactionDataList = new ArrayList<>();
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+        for (TransactionData transactionData : transactionDataList) {
+            switch (transactionData.getType()) {
+
+                case PAYMENT:
+                    PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData;
+                    if (!Objects.equals(paymentTransactionData.getRecipient(), address)) {
+                        // Outgoing payment from this account
+                        outgoingPaymentRecipients.add(paymentTransactionData.getRecipient());
+                    }
+                    break;
+
+                case TRANSFER_ASSET:
+                    TransferAssetTransactionData transferAssetTransactionData = (TransferAssetTransactionData) transactionData;
+                    if (transferAssetTransactionData.getAssetId() == Asset.QORT) {
+                        if (!Objects.equals(transferAssetTransactionData.getRecipient(), address)) {
+                            // Outgoing payment from this account
+                            outgoingPaymentRecipients.add(transferAssetTransactionData.getRecipient());
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        return outgoingPaymentRecipients;
+    }
+
+    private boolean hasZeroTransactions(String address) {
+        List<TransactionData> transactionDataList = this.paymentsByAddress.get(address);
+        if (transactionDataList == null) {
+            return true;
+        }
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+        return transactionDataList.isEmpty();
+    }
+
+    private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
+        // Fetch all relevant transactions for this account
+        List<byte[]> signatures = repository.getTransactionRepository()
+                .getSignaturesMatchingCriteria(null, null, null, txTypes,
+                        null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED,
+                        null, null, reverse);
+
+        List<TransactionData> transactionDataList = new ArrayList<>();
+
+        for (byte[] signature : signatures) {
+            // Fetch transaction data
+            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+            if (transactionData == null) {
+                continue;
+            }
+            transactionDataList.add(transactionData);
+        }
+
+        return transactionDataList;
+    }
+}

src/main/java/org/qortal/api/AmountTypeAdapter.java

@@ -1,10 +1,9 @@
 package org.qortal.api;
 
-import java.math.BigDecimal;
+import org.qortal.utils.Amounts;
 
 import javax.xml.bind.annotation.adapters.XmlAdapter;
-
-import org.qortal.utils.Amounts;
+import java.math.BigDecimal;
 
 public class AmountTypeAdapter extends XmlAdapter<String, Long> {
 

src/main/java/org/qortal/api/ApiError.java

@@ -1,13 +1,12 @@
 package org.qortal.api;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
-
-import java.util.Map;
-
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlRootElement;
+import java.util.Map;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
 
 @XmlAccessorType(XmlAccessType.NONE)
 @XmlRootElement
@@ -79,7 +78,7 @@ public enum ApiError {
 	// BUYER_ALREADY_OWNER(411, 422),
 
 	// POLLS
-	// POLL_NO_EXISTS(501, 404),
+	POLL_NO_EXISTS(501, 404),
 	// POLL_ALREADY_EXISTS(502, 422),
 	// DUPLICATE_OPTION(503, 422),
 	// POLL_OPTION_NO_EXISTS(504, 404),

src/main/java/org/qortal/api/ApiErrorHandler.java

@@ -1,18 +1,17 @@
 package org.qortal.api;
 
-import java.io.IOException;
-
-import javax.servlet.RequestDispatcher;
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.eclipse.jetty.server.Request;
 import org.eclipse.jetty.server.handler.ErrorHandler;
 import org.qortal.settings.Settings;
 
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
 public class ApiErrorHandler extends ErrorHandler {
 
 	private static final Logger LOGGER = LogManager.getLogger(ApiErrorHandler.class);

src/main/java/org/qortal/api/ApiExceptionFactory.java

@@ -1,9 +1,9 @@
 package org.qortal.api;
 
-import javax.servlet.http.HttpServletRequest;
-
 import org.qortal.globalization.Translator;
 
+import javax.servlet.http.HttpServletRequest;
+
 public enum ApiExceptionFactory {
 	INSTANCE;
 

src/main/java/org/qortal/api/ApiRequest.java

@@ -1,35 +1,24 @@
 package org.qortal.api;
 
+import org.eclipse.persistence.exceptions.XMLMarshalException;
+import org.eclipse.persistence.jaxb.JAXBContextFactory;
+import org.eclipse.persistence.jaxb.MarshallerProperties;
+import org.eclipse.persistence.jaxb.UnmarshallerProperties;
+
+import javax.net.ssl.*;
+import javax.xml.bind.*;
+import javax.xml.transform.stream.StreamSource;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
-import java.net.HttpURLConnection;
-import java.net.InetSocketAddress;
-import java.net.Socket;
-import java.net.SocketAddress;
-import java.net.URL;
-import java.net.URLEncoder;
+import java.io.Writer;
+import java.net.*;
 import java.util.Collections;
 import java.util.Map;
 import java.util.Scanner;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.net.ssl.HttpsURLConnection;
-import javax.net.ssl.SNIHostName;
-import javax.net.ssl.SNIServerName;
-import javax.net.ssl.SSLParameters;
-import javax.net.ssl.SSLSocket;
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.UnmarshalException;
-import javax.xml.bind.Unmarshaller;
-import javax.xml.transform.stream.StreamSource;
-
-import org.eclipse.persistence.exceptions.XMLMarshalException;
-import org.eclipse.persistence.jaxb.JAXBContextFactory;
-import org.eclipse.persistence.jaxb.UnmarshallerProperties;
-
 public class ApiRequest {
 
 	private static final Pattern proxyUrlPattern = Pattern.compile("(https://)([^@:/]+)@([0-9.]{7,15})(/.*)");
@@ -107,6 +96,36 @@ public class ApiRequest {
 		}
 	}
 
+	private static Marshaller createMarshaller(Class<?> objectClass) {
+		try {
+			// Create JAXB context aware of object's class
+			JAXBContext jc = JAXBContextFactory.createContext(new Class[] { objectClass }, null);
+
+			// Create marshaller
+			Marshaller marshaller = jc.createMarshaller();
+
+			// Set the marshaller media type to JSON
+			marshaller.setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
+
+			// Tell marshaller not to include JSON root element in the output
+			marshaller.setProperty(MarshallerProperties.JSON_INCLUDE_ROOT, false);
+
+			return marshaller;
+		} catch (JAXBException e) {
+			throw new RuntimeException("Unable to create API marshaller", e);
+		}
+	}
+
+	public static void marshall(Writer writer, Object object) throws IOException {
+		Marshaller marshaller = createMarshaller(object.getClass());
+
+		try {
+			marshaller.marshal(object, writer);
+		} catch (JAXBException e) {
+			throw new IOException("Unable to create marshall object for API", e);
+		}
+	}
+
 	public static String getParamsString(Map<String, String> params) {
 		StringBuilder result = new StringBuilder();
 
@@ -122,7 +141,7 @@ public class ApiRequest {
 		}
 
 		String resultString = result.toString();
-		return resultString.length() > 0 ? resultString.substring(0, resultString.length() - 1) : resultString;
+		return !resultString.isEmpty() ? resultString.substring(0, resultString.length() - 1) : resultString;
 	}
 
 	/**

src/main/java/org/qortal/api/ApiService.java

@@ -1,33 +1,10 @@
 package org.qortal.api;
 
 import io.swagger.v3.jaxrs2.integration.resources.OpenApiResource;
-
-import java.io.InputStream;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.security.KeyStore;
-import java.security.SecureRandom;
-
-import javax.net.ssl.KeyManagerFactory;
-import javax.net.ssl.SSLContext;
-
-import org.checkerframework.checker.units.qual.A;
 import org.eclipse.jetty.http.HttpVersion;
 import org.eclipse.jetty.rewrite.handler.RedirectPatternRule;
 import org.eclipse.jetty.rewrite.handler.RewriteHandler;
-import org.eclipse.jetty.server.CustomRequestLog;
-import org.eclipse.jetty.server.DetectorConnectionFactory;
-import org.eclipse.jetty.server.HttpConfiguration;
-import org.eclipse.jetty.server.HttpConnectionFactory;
-import org.eclipse.jetty.server.RequestLog;
-import org.eclipse.jetty.server.RequestLogWriter;
-import org.eclipse.jetty.server.SecureRequestCustomizer;
-import org.eclipse.jetty.server.Server;
-import org.eclipse.jetty.server.ServerConnector;
-import org.eclipse.jetty.server.SslConnectionFactory;
+import org.eclipse.jetty.server.*;
 import org.eclipse.jetty.server.handler.ErrorHandler;
 import org.eclipse.jetty.server.handler.InetAccessHandler;
 import org.eclipse.jetty.servlet.DefaultServlet;
@@ -41,8 +18,21 @@ import org.glassfish.jersey.servlet.ServletContainer;
 import org.qortal.api.resource.AnnotationPostProcessor;
 import org.qortal.api.resource.ApiDefinition;
 import org.qortal.api.websocket.*;
+import org.qortal.network.Network;
 import org.qortal.settings.Settings;
 
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.servlet.http.HttpServletRequest;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+
 public class ApiService {
 
 	private static ApiService instance;
@@ -51,9 +41,12 @@ public class ApiService {
 	private Server server;
 	private ApiKey apiKey;
 
+	public static final String API_VERSION_HEADER = "X-API-VERSION";
+
 	private ApiService() {
 		this.config = new ResourceConfig();
-		this.config.packages("org.qortal.api.resource");
+		this.config.packages("org.qortal.api.resource", "org.qortal.api.restricted.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);
@@ -93,7 +86,7 @@ public class ApiService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");
 
 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");
 
 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
@@ -123,13 +116,13 @@ public class ApiService {
 				ServerConnector portUnifiedConnector = new ServerConnector(this.server,
 						new DetectorConnectionFactory(sslConnectionFactory),
 						httpConnectionFactory);
-				portUnifiedConnector.setHost(Settings.getInstance().getBindAddress());
+				portUnifiedConnector.setHost(Network.getInstance().getBindAddress());
 				portUnifiedConnector.setPort(Settings.getInstance().getApiPort());
 
 				this.server.addConnector(portUnifiedConnector);
 			} else {
 				// Non-SSL
-				InetAddress bindAddr = InetAddress.getByName(Settings.getInstance().getBindAddress());
+				InetAddress bindAddr = InetAddress.getByName(Network.getInstance().getBindAddress());
 				InetSocketAddress endpoint = new InetSocketAddress(bindAddr, Settings.getInstance().getApiPort());
 				this.server = new Server(endpoint);
 			}
@@ -202,8 +195,10 @@ public class ApiService {
 
 			context.addServlet(AdminStatusWebSocket.class, "/websockets/admin/status");
 			context.addServlet(BlocksWebSocket.class, "/websockets/blocks");
+			context.addServlet(DataMonitorSocket.class, "/websockets/datamonitor");
 			context.addServlet(ActiveChatsWebSocket.class, "/websockets/chat/active/*");
 			context.addServlet(ChatMessagesWebSocket.class, "/websockets/chat/messages");
+			context.addServlet(UnsignedFeesSocket.class, "/websockets/crosschain/unsignedfees");
 			context.addServlet(TradeOffersWebSocket.class, "/websockets/crosschain/tradeoffers");
 			context.addServlet(TradeBotWebSocket.class, "/websockets/crosschain/tradebot");
 			context.addServlet(TradePresenceWebSocket.class, "/websockets/crosschain/tradepresence");
@@ -230,4 +225,19 @@ public class ApiService {
 		this.server = null;
 	}
 
+	public static int getApiVersion(HttpServletRequest request) {
+		// Get API version
+		String apiVersionString = request.getHeader(API_VERSION_HEADER);
+		if (apiVersionString == null) {
+			// Try query string - this is needed to avoid a CORS preflight. See: https://stackoverflow.com/a/43881141
+			apiVersionString = request.getParameter("apiVersion");
+		}
+
+		int apiVersion = 1;
+		if (apiVersionString != null) {
+			apiVersion = Integer.parseInt(apiVersionString);
+		}
+		return apiVersion;
+	}
+
 }

src/main/java/org/qortal/api/Base58TypeAdapter.java

@@ -1,9 +1,9 @@
 package org.qortal.api;
 
-import javax.xml.bind.annotation.adapters.XmlAdapter;
-
 import org.qortal.utils.Base58;
 
+import javax.xml.bind.annotation.adapters.XmlAdapter;
+
 public class Base58TypeAdapter extends XmlAdapter<String, byte[]> {
 
 	@Override

src/main/java/org/qortal/api/BigDecimalTypeAdapter.java

@@ -1,8 +1,7 @@
 package org.qortal.api;
 
-import java.math.BigDecimal;
-
 import javax.xml.bind.annotation.adapters.XmlAdapter;
+import java.math.BigDecimal;
 
 public class BigDecimalTypeAdapter extends XmlAdapter<String, BigDecimal> {
 

src/main/java/org/qortal/api/Constants.java

@@ -4,9 +4,11 @@ import io.swagger.v3.oas.models.Operation;
 import io.swagger.v3.oas.models.PathItem;
 import io.swagger.v3.oas.models.info.Info;
 import io.swagger.v3.oas.models.responses.ApiResponse;
-import static java.util.Arrays.asList;
+
 import java.util.List;
 
+import static java.util.Arrays.asList;
+
 class Constants {
 	public static final String APIERROR_CONTEXT_PATH = "/Api";
 	public static final String APIERROR_KEY = "ApiError/%s";

src/main/java/org/qortal/api/DevProxyService.java

@@ -0,0 +1,174 @@
+package org.qortal.api;
+
+import io.swagger.v3.jaxrs2.integration.resources.OpenApiResource;
+import org.eclipse.jetty.http.HttpVersion;
+import org.eclipse.jetty.rewrite.handler.RewriteHandler;
+import org.eclipse.jetty.server.*;
+import org.eclipse.jetty.server.handler.ErrorHandler;
+import org.eclipse.jetty.server.handler.InetAccessHandler;
+import org.eclipse.jetty.servlet.FilterHolder;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.eclipse.jetty.servlets.CrossOriginFilter;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.servlet.ServletContainer;
+import org.qortal.api.resource.AnnotationPostProcessor;
+import org.qortal.api.resource.ApiDefinition;
+import org.qortal.network.Network;
+import org.qortal.repository.DataException;
+import org.qortal.settings.Settings;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+
+public class DevProxyService {
+
+	private static DevProxyService instance;
+
+	private final ResourceConfig config;
+	private Server server;
+
+	private DevProxyService() {
+		this.config = new ResourceConfig();
+		this.config.packages("org.qortal.api.proxy.resource", "org.qortal.api.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
+		this.config.register(OpenApiResource.class);
+		this.config.register(ApiDefinition.class);
+		this.config.register(AnnotationPostProcessor.class);
+	}
+
+	public static DevProxyService getInstance() {
+		if (instance == null)
+			instance = new DevProxyService();
+
+		return instance;
+	}
+
+	public Iterable<Class<?>> getResources() {
+		return this.config.getClasses();
+	}
+
+	public void start() throws DataException {
+		try {
+			// Create API server
+
+			// SSL support if requested
+			String keystorePathname = Settings.getInstance().getSslKeystorePathname();
+			String keystorePassword = Settings.getInstance().getSslKeystorePassword();
+
+			if (keystorePathname != null && keystorePassword != null) {
+				// SSL version
+				if (!Files.isReadable(Path.of(keystorePathname)))
+					throw new RuntimeException("Failed to start SSL API due to broken keystore");
+
+				// BouncyCastle-specific SSLContext build
+				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");
+
+				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
+
+				try (InputStream keystoreStream = Files.newInputStream(Paths.get(keystorePathname))) {
+					keyStore.load(keystoreStream, keystorePassword.toCharArray());
+				}
+
+				keyManagerFactory.init(keyStore, keystorePassword.toCharArray());
+				sslContext.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom());
+
+				SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
+				sslContextFactory.setSslContext(sslContext);
+
+				this.server = new Server();
+
+				HttpConfiguration httpConfig = new HttpConfiguration();
+				httpConfig.setSecureScheme("https");
+				httpConfig.setSecurePort(Settings.getInstance().getDevProxyPort());
+
+				SecureRequestCustomizer src = new SecureRequestCustomizer();
+				httpConfig.addCustomizer(src);
+
+				HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(httpConfig);
+				SslConnectionFactory sslConnectionFactory = new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString());
+
+				ServerConnector portUnifiedConnector = new ServerConnector(this.server,
+						new DetectorConnectionFactory(sslConnectionFactory),
+						httpConnectionFactory);
+				portUnifiedConnector.setHost(Network.getInstance().getBindAddress());
+				portUnifiedConnector.setPort(Settings.getInstance().getDevProxyPort());
+
+				this.server.addConnector(portUnifiedConnector);
+			} else {
+				// Non-SSL
+				InetAddress bindAddr = InetAddress.getByName(Network.getInstance().getBindAddress());
+				InetSocketAddress endpoint = new InetSocketAddress(bindAddr, Settings.getInstance().getDevProxyPort());
+				this.server = new Server(endpoint);
+			}
+
+			// Error handler
+			ErrorHandler errorHandler = new ApiErrorHandler();
+			this.server.setErrorHandler(errorHandler);
+
+			// Request logging
+			if (Settings.getInstance().isDevProxyLoggingEnabled()) {
+				RequestLogWriter logWriter = new RequestLogWriter("devproxy-requests.log");
+				logWriter.setAppend(true);
+				logWriter.setTimeZone("UTC");
+				RequestLog requestLog = new CustomRequestLog(logWriter, CustomRequestLog.EXTENDED_NCSA_FORMAT);
+				this.server.setRequestLog(requestLog);
+			}
+
+			// Access handler (currently no whitelist is used)
+			InetAccessHandler accessHandler = new InetAccessHandler();
+			this.server.setHandler(accessHandler);
+
+			// URL rewriting
+			RewriteHandler rewriteHandler = new RewriteHandler();
+			accessHandler.setHandler(rewriteHandler);
+
+			// Context
+			ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
+			context.setContextPath("/");
+			rewriteHandler.setHandler(context);
+
+			// Cross-origin resource sharing
+			FilterHolder corsFilterHolder = new FilterHolder(CrossOriginFilter.class);
+			corsFilterHolder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*");
+			corsFilterHolder.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET, POST, DELETE");
+			corsFilterHolder.setInitParameter(CrossOriginFilter.CHAIN_PREFLIGHT_PARAM, "false");
+			context.addFilter(corsFilterHolder, "/*", null);
+
+			// API servlet
+			ServletContainer container = new ServletContainer(this.config);
+			ServletHolder apiServlet = new ServletHolder(container);
+			apiServlet.setInitOrder(1);
+			context.addServlet(apiServlet, "/*");
+
+			// Start server
+			this.server.start();
+		} catch (Exception e) {
+			// Failed to start
+			throw new DataException("Failed to start developer proxy", e);
+		}
+	}
+
+	public void stop() {
+		try {
+			// Stop server
+			this.server.stop();
+		} catch (Exception e) {
+			// Failed to stop
+		}
+
+		this.server = null;
+		instance = null;
+	}
+
+}

src/main/java/org/qortal/api/DomainMapService.java

@@ -3,7 +3,6 @@ package org.qortal.api;
 import io.swagger.v3.jaxrs2.integration.resources.OpenApiResource;
 import org.eclipse.jetty.http.HttpVersion;
 import org.eclipse.jetty.rewrite.handler.RewriteHandler;
-import org.eclipse.jetty.rewrite.handler.RewritePatternRule;
 import org.eclipse.jetty.server.*;
 import org.eclipse.jetty.server.handler.ErrorHandler;
 import org.eclipse.jetty.server.handler.InetAccessHandler;
@@ -16,6 +15,7 @@ import org.glassfish.jersey.server.ResourceConfig;
 import org.glassfish.jersey.servlet.ServletContainer;
 import org.qortal.api.resource.AnnotationPostProcessor;
 import org.qortal.api.resource.ApiDefinition;
+import org.qortal.network.Network;
 import org.qortal.settings.Settings;
 
 import javax.net.ssl.KeyManagerFactory;
@@ -38,7 +38,8 @@ public class DomainMapService {
 
 	private DomainMapService() {
 		this.config = new ResourceConfig();
-		this.config.packages("org.qortal.api.domainmap.resource");
+		this.config.packages("org.qortal.api.resource", "org.qortal.api.domainmap.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);
@@ -69,7 +70,7 @@ public class DomainMapService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");
 
 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");
 
 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
@@ -99,13 +100,13 @@ public class DomainMapService {
 				ServerConnector portUnifiedConnector = new ServerConnector(this.server,
 						new DetectorConnectionFactory(sslConnectionFactory),
 						httpConnectionFactory);
-				portUnifiedConnector.setHost(Settings.getInstance().getBindAddress());
+				portUnifiedConnector.setHost(Network.getInstance().getBindAddress());
 				portUnifiedConnector.setPort(Settings.getInstance().getDomainMapPort());
 
 				this.server.addConnector(portUnifiedConnector);
 			} else {
 				// Non-SSL
-				InetAddress bindAddr = InetAddress.getByName(Settings.getInstance().getBindAddress());
+				InetAddress bindAddr = InetAddress.getByName(Network.getInstance().getBindAddress());
 				InetSocketAddress endpoint = new InetSocketAddress(bindAddr, Settings.getInstance().getDomainMapPort());
 				this.server = new Server(endpoint);
 			}

src/main/java/org/qortal/api/GatewayService.java

@@ -15,6 +15,7 @@ import org.glassfish.jersey.server.ResourceConfig;
 import org.glassfish.jersey.servlet.ServletContainer;
 import org.qortal.api.resource.AnnotationPostProcessor;
 import org.qortal.api.resource.ApiDefinition;
+import org.qortal.network.Network;
 import org.qortal.settings.Settings;
 
 import javax.net.ssl.KeyManagerFactory;
@@ -37,7 +38,8 @@ public class GatewayService {
 
 	private GatewayService() {
 		this.config = new ResourceConfig();
-		this.config.packages("org.qortal.api.gateway.resource");
+		this.config.packages("org.qortal.api.resource", "org.qortal.api.gateway.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);
@@ -68,7 +70,7 @@ public class GatewayService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");
 
 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");
 
 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
@@ -98,13 +100,13 @@ public class GatewayService {
 				ServerConnector portUnifiedConnector = new ServerConnector(this.server,
 						new DetectorConnectionFactory(sslConnectionFactory),
 						httpConnectionFactory);
-				portUnifiedConnector.setHost(Settings.getInstance().getBindAddress());
+				portUnifiedConnector.setHost(Network.getInstance().getBindAddress());
 				portUnifiedConnector.setPort(Settings.getInstance().getGatewayPort());
 
 				this.server.addConnector(portUnifiedConnector);
 			} else {
 				// Non-SSL
-				InetAddress bindAddr = InetAddress.getByName(Settings.getInstance().getBindAddress());
+				InetAddress bindAddr = InetAddress.getByName(Network.getInstance().getBindAddress());
 				InetSocketAddress endpoint = new InetSocketAddress(bindAddr, Settings.getInstance().getGatewayPort());
 				this.server = new Server(endpoint);
 			}

src/main/java/org/qortal/api/HTMLParser.java

@@ -1,32 +1,80 @@
 package org.qortal.api;
 
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.select.Elements;
-
+import org.qortal.arbitrary.misc.Service;
+import java.util.Objects;
 public class HTMLParser {
 
     private static final Logger LOGGER = LogManager.getLogger(HTMLParser.class);
 
-    private String linkPrefix;
+    private String qdnBase;
+    private String qdnBaseWithPath;
     private byte[] data;
+    private String qdnContext;
+    private String resourceId;
+    private Service service;
+    private String identifier;
+    private String path;
+    private String theme;
+    private String lang;
+    private boolean usingCustomRouting;
 
-    public HTMLParser(String resourceId, String inPath, String prefix, boolean usePrefix, byte[] data) {
-        String inPathWithoutFilename = inPath.substring(0, inPath.lastIndexOf('/'));
-        this.linkPrefix = usePrefix ? String.format("%s/%s%s", prefix, resourceId, inPathWithoutFilename) : "";
+    public HTMLParser(String resourceId, String inPath, String prefix, boolean includeResourceIdInPrefix, byte[] data,
+                      String qdnContext, Service service, String identifier, String theme, boolean usingCustomRouting,  String lang) {
+        String inPathWithoutFilename = inPath.contains("/") ? inPath.substring(0, inPath.lastIndexOf('/')) : String.format("/%s",inPath);
+        this.qdnBase = includeResourceIdInPrefix ? String.format("%s/%s", prefix, resourceId) : prefix;
+        this.qdnBaseWithPath = includeResourceIdInPrefix ? String.format("%s/%s%s", prefix, resourceId, inPathWithoutFilename) : String.format("%s%s", prefix, inPathWithoutFilename);
         this.data = data;
+        this.qdnContext = qdnContext;
+        this.resourceId = resourceId;
+        this.service = service;
+        this.identifier = identifier;
+        this.path = inPath;
+        this.theme = theme;
+        this.lang = lang;
+        this.usingCustomRouting = usingCustomRouting;
     }
 
     public void addAdditionalHeaderTags() {
         String fileContents = new String(data);
         Document document = Jsoup.parse(fileContents);
-        String baseUrl = this.linkPrefix + "/";
         Elements head = document.getElementsByTag("head");
         if (!head.isEmpty()) {
+            // Add q-apps script tag
+            String qAppsScriptElement = String.format("<script src=\"/apps/q-apps.js?time=%d\">", System.currentTimeMillis());
+            head.get(0).prepend(qAppsScriptElement);
+
+            // Add q-apps gateway script tag if in gateway mode
+            if (Objects.equals(this.qdnContext, "gateway")) {
+                String qAppsGatewayScriptElement = String.format("<script src=\"/apps/q-apps-gateway.js?time=%d\">", System.currentTimeMillis());
+                head.get(0).prepend(qAppsGatewayScriptElement);
+            }
+
+            // Escape and add vars
+            String qdnContext = this.qdnContext != null ? this.qdnContext.replace("\\", "").replace("\"","\\\"") : "";
+            String service = this.service.toString().replace("\\", "").replace("\"","\\\"");
+            String name = this.resourceId != null ? this.resourceId.replace("\\", "").replace("\"","\\\"") : "";
+            String identifier = this.identifier != null ? this.identifier.replace("\\", "").replace("\"","\\\"") : "";
+            String path = this.path != null ? this.path.replace("\\", "").replace("\"","\\\"") : "";
+            String theme = this.theme != null ? this.theme.replace("\\", "").replace("\"","\\\"") : "";
+            String lang = this.lang != null ? this.lang.replace("\\", "").replace("\"", "\\\"") : "";
+            String qdnBase = this.qdnBase != null ? this.qdnBase.replace("\\", "").replace("\"","\\\"") : "";
+            String qdnBaseWithPath = this.qdnBaseWithPath != null ? this.qdnBaseWithPath.replace("\\", "").replace("\"","\\\"") : "";
+            String qdnContextVar = String.format(
+                "<script>var _qdnContext=\"%s\"; var _qdnTheme=\"%s\"; var _qdnLang=\"%s\"; var _qdnService=\"%s\"; var _qdnName=\"%s\"; var _qdnIdentifier=\"%s\"; var _qdnPath=\"%s\"; var _qdnBase=\"%s\"; var _qdnBaseWithPath=\"%s\";</script>",
+                qdnContext, theme, lang, service, name, identifier, path, qdnBase, qdnBaseWithPath
+              );
+            head.get(0).prepend(qdnContextVar);
+
             // Add base href tag
-            String baseElement = String.format("<base href=\"%s\">", baseUrl);
+            // Exclude the path if this request was routed back to the index automatically
+            String baseHref = this.usingCustomRouting ? this.qdnBase : this.qdnBaseWithPath;
+            String baseElement = String.format("<base href=\"%s/\">", baseHref);
             head.get(0).prepend(baseElement);
 
             // Add meta charset tag
@@ -39,7 +87,7 @@ public class HTMLParser {
     }
 
     public static boolean isHtmlFile(String path) {
-        if (path.endsWith(".html") || path.endsWith(".htm")) {
+        if (path.endsWith(".html") || path.endsWith(".htm") || path.isEmpty()) {
             return true;
         }
         return false;

src/main/java/org/qortal/api/RewardSharePercentTypeAdapter.java

@@ -1,8 +1,7 @@
 package org.qortal.api;
 
-import java.math.BigDecimal;
-
 import javax.xml.bind.annotation.adapters.XmlAdapter;
+import java.math.BigDecimal;
 
 public class RewardSharePercentTypeAdapter extends XmlAdapter<String, Integer> {
 

src/main/java/org/qortal/api/SearchMode.java

@@ -0,0 +1,6 @@
+package org.qortal.api;
+
+public enum SearchMode {
+    LATEST,
+    ALL
+}

src/main/java/org/qortal/api/Security.java

@@ -5,17 +5,30 @@ import org.qortal.arbitrary.misc.Service;
 import org.qortal.controller.arbitrary.ArbitraryDataRenderManager;
 import org.qortal.settings.Settings;
 
+import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 
-import javax.servlet.http.HttpServletRequest;
-
 public abstract class Security {
 
 	public static final String API_KEY_HEADER = "X-API-KEY";
 
+	/**
+	 * Check API call is allowed, retrieving the API key from the request header or GET/POST parameters where required
+	 * @param request
+	 */
 	public static void checkApiCallAllowed(HttpServletRequest request) {
+		checkApiCallAllowed(request, null);
+	}
+
+	/**
+	 * Check API call is allowed, retrieving the API key first from the passedApiKey parameter, with a fallback
+	 * to the request header or GET/POST parameters when null.
+	 * @param request
+	 * @param passedApiKey - the API key to test, or null if it should be retrieved from the request headers.
+	 */
+	public static void checkApiCallAllowed(HttpServletRequest request, String passedApiKey) {
 		// We may want to allow automatic authentication for local requests, if enabled in settings
 		boolean localAuthBypassEnabled = Settings.getInstance().isLocalAuthBypassEnabled();
 		if (localAuthBypassEnabled) {
@@ -38,7 +51,10 @@ public abstract class Security {
 		}
 
 		// We require an API key to be passed
-		String passedApiKey = request.getHeader(API_KEY_HEADER);
+		if (passedApiKey == null) {
+			// API call not passed as a parameter, so try the header
+			passedApiKey = request.getHeader(API_KEY_HEADER);
+		}
 		if (passedApiKey == null) {
 			// Try query string - this is needed to avoid a CORS preflight. See: https://stackoverflow.com/a/43881141
 			passedApiKey = request.getParameter("apiKey");
@@ -56,7 +72,7 @@ public abstract class Security {
 	public static void disallowLoopbackRequests(HttpServletRequest request) {
 		try {
 			InetAddress remoteAddr = InetAddress.getByName(request.getRemoteAddr());
-			if (remoteAddr.isLoopbackAddress()) {
+			if (remoteAddr.isLoopbackAddress() && !Settings.getInstance().isGatewayLoopbackEnabled()) {
 				throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.UNAUTHORIZED, "Local requests not allowed");
 			}
 		} catch (UnknownHostException e) {
@@ -84,9 +100,9 @@ public abstract class Security {
 		}
 	}
 
-	public static void requirePriorAuthorizationOrApiKey(HttpServletRequest request, String resourceId, Service service, String identifier) {
+	public static void requirePriorAuthorizationOrApiKey(HttpServletRequest request, String resourceId, Service service, String identifier, String apiKey) {
 		try {
-			Security.checkApiCallAllowed(request);
+			Security.checkApiCallAllowed(request, apiKey);
 
 		} catch (ApiException e) {
 			// API call wasn't allowed, but maybe it was pre-authorized

src/main/java/org/qortal/api/TransactionCountMapXmlAdapter.java

@@ -1,18 +1,17 @@
 package org.qortal.api;
 
+import org.eclipse.persistence.oxm.annotations.XmlVariableNode;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import javax.xml.bind.annotation.XmlTransient;
+import javax.xml.bind.annotation.XmlValue;
+import javax.xml.bind.annotation.adapters.XmlAdapter;
 import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import javax.xml.bind.annotation.XmlTransient;
-import javax.xml.bind.annotation.XmlValue;
-import javax.xml.bind.annotation.adapters.XmlAdapter;
-
-import org.eclipse.persistence.oxm.annotations.XmlVariableNode;
-import org.qortal.transaction.Transaction.TransactionType;
-
 public class TransactionCountMapXmlAdapter extends XmlAdapter<TransactionCountMapXmlAdapter.StringIntegerMap, Map<TransactionType, Integer>> {
 
 	public static class StringIntegerMap {

src/main/java/org/qortal/api/domainmap/resource/DomainMapResource.java

@@ -42,16 +42,16 @@ public class DomainMapResource {
             // Build synchronously, so that we don't need to make the summary API endpoints available over
             // the domain map server. This means that there will be no loading screen, but this is potentially
             // preferred in this situation anyway (e.g. to avoid confusing search engine robots).
-            return this.get(domainMap.get(request.getServerName()), ResourceIdType.NAME, Service.WEBSITE, inPath, null, "", false, false);
+            return this.get(domainMap.get(request.getServerName()), ResourceIdType.NAME, Service.WEBSITE, null, inPath, null, "", false, false);
         }
         return ArbitraryDataRenderer.getResponse(response, 404, "Error 404: File Not Found");
     }
 
-    private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String inPath,
-                                    String secret58, String prefix, boolean usePrefix, boolean async) {
+    private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String identifier,
+                                    String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async) {
 
-        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, inPath,
-                secret58, prefix, usePrefix, async, request, response, context);
+        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, identifier, inPath,
+                secret58, prefix, includeResourceIdInPrefix, async, "domainMap", request, response, context);
         return renderer.render();
     }
 

src/main/java/org/qortal/api/gateway/resource/GatewayResource.java

@@ -2,6 +2,9 @@ package org.qortal.api.gateway.resource;
 
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import org.apache.commons.lang3.StringUtils;
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.Security;
 import org.qortal.arbitrary.ArbitraryDataFile;
 import org.qortal.arbitrary.ArbitraryDataFile.ResourceIdType;
@@ -10,12 +13,21 @@ import org.qortal.arbitrary.ArbitraryDataRenderer;
 import org.qortal.arbitrary.ArbitraryDataResource;
 import org.qortal.arbitrary.misc.Service;
 import org.qortal.data.arbitrary.ArbitraryResourceStatus;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import javax.ws.rs.*;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
 import javax.ws.rs.core.Context;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
 
 
 @Path("/")
@@ -26,36 +38,12 @@ public class GatewayResource {
     @Context HttpServletResponse response;
     @Context ServletContext context;
 
-    /**
-     * We need to allow resource status checking (and building) via the gateway, as the node's API port
-     * may not be forwarded and will almost certainly not be authenticated. Since gateways allow for
-     * all resources to be loaded except those that are blocked, there is no need for authentication.
-     */
-    @GET
-    @Path("/arbitrary/resource/status/{service}/{name}")
-    public ArbitraryResourceStatus getDefaultResourceStatus(@PathParam("service") Service service,
-                                                             @PathParam("name") String name,
-                                                             @QueryParam("build") Boolean build) {
-
-        return this.getStatus(service, name, null, build);
-    }
-
-    @GET
-    @Path("/arbitrary/resource/status/{service}/{name}/{identifier}")
-    public ArbitraryResourceStatus getResourceStatus(@PathParam("service") Service service,
-                                                      @PathParam("name") String name,
-                                                      @PathParam("identifier") String identifier,
-                                                      @QueryParam("build") Boolean build) {
-
-        return this.getStatus(service, name, identifier, build);
-    }
-
     private ArbitraryResourceStatus getStatus(Service service, String name, String identifier, Boolean build) {
 
         // If "build=true" has been specified in the query string, build the resource before returning its status
-        if (build != null && build == true) {
-            ArbitraryDataReader reader = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, null);
+        if (build != null && build) {
             try {
+                ArbitraryDataReader reader = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, null);
                 if (!reader.isBuilding()) {
                     reader.loadSynchronously(false);
                 }
@@ -64,8 +52,13 @@ public class GatewayResource {
             }
         }
 
-        ArbitraryDataResource resource = new ArbitraryDataResource(name, ResourceIdType.NAME, service, identifier);
-        return resource.getStatus(false);
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            ArbitraryDataResource resource = new ArbitraryDataResource(name, ResourceIdType.NAME, service, identifier);
+            return resource.getStatus(repository);
+
+        } catch (DataException e) {
+            throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+        }
     }
 
 
@@ -76,50 +69,83 @@ public class GatewayResource {
 
 
     @GET
-    @Path("{name}/{path:.*}")
+    @Path("{path:.*}")
     @SecurityRequirement(name = "apiKey")
-    public HttpServletResponse getPathByName(@PathParam("name") String name,
-                                             @PathParam("path") String inPath) {
+    public HttpServletResponse getPath(@PathParam("path") String inPath) {
         // Block requests from localhost, to prevent websites/apps from running javascript that fetches unvetted data
         Security.disallowLoopbackRequests(request);
-        return this.get(name, ResourceIdType.NAME, Service.WEBSITE, inPath, null, "", true, true);
-    }
-
-    @GET
-    @Path("{name}")
-    @SecurityRequirement(name = "apiKey")
-    public HttpServletResponse getIndexByName(@PathParam("name") String name) {
-        // Block requests from localhost, to prevent websites/apps from running javascript that fetches unvetted data
-        Security.disallowLoopbackRequests(request);
-        return this.get(name, ResourceIdType.NAME, Service.WEBSITE, "/", null, "", true, true);
-    }
-
-
-    // Optional /site alternative for backwards support
-
-    @GET
-    @Path("/site/{name}/{path:.*}")
-    public HttpServletResponse getSitePathByName(@PathParam("name") String name,
-                                                 @PathParam("path") String inPath) {
-        // Block requests from localhost, to prevent websites/apps from running javascript that fetches unvetted data
-        Security.disallowLoopbackRequests(request);
-        return this.get(name, ResourceIdType.NAME, Service.WEBSITE, inPath, null, "/site", true, true);
-    }
-
-    @GET
-    @Path("/site/{name}")
-    public HttpServletResponse getSiteIndexByName(@PathParam("name") String name) {
-        // Block requests from localhost, to prevent websites/apps from running javascript that fetches unvetted data
-        Security.disallowLoopbackRequests(request);
-        return this.get(name, ResourceIdType.NAME, Service.WEBSITE, "/", null, "/site", true, true);
+        return this.parsePath(inPath, "gateway", null, true, true);
     }
 
     
-    private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String inPath,
-                                    String secret58, String prefix, boolean usePrefix, boolean async) {
+    private HttpServletResponse parsePath(String inPath, String qdnContext, String secret58, boolean includeResourceIdInPrefix, boolean async) {
 
-        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, inPath,
-                secret58, prefix, usePrefix, async, request, response, context);
+        if (inPath == null || inPath.isEmpty()) {
+            // Assume not a real file
+            return ArbitraryDataRenderer.getResponse(response, 404, "Error 404: File Not Found");
+        }
+
+        // Default service is WEBSITE
+        Service service = Service.WEBSITE;
+        String name = null;
+        String identifier = null;
+        String outPath = "";
+        List<String> prefixParts = new ArrayList<>();
+
+        if (!inPath.contains("/")) {
+            // Assume entire inPath is a registered name
+            name = inPath;
+        }
+        else {
+            // Parse the path to determine what we need to load
+            List<String> parts = new LinkedList<>(Arrays.asList(inPath.split("/")));
+
+            // Check if the first element is a service
+            try {
+                Service parsedService = Service.valueOf(parts.get(0).toUpperCase());
+                if (parsedService != null) {
+                    // First element matches a service, so we can assume it is one
+                    service = parsedService;
+                    parts.remove(0);
+                    prefixParts.add(service.name());
+                }
+            } catch (IllegalArgumentException e) {
+                // Not a service
+            }
+
+            if (parts.isEmpty()) {
+                // We need more than just a service
+                return ArbitraryDataRenderer.getResponse(response, 404, "Error 404: File Not Found");
+            }
+
+            // Service is removed, so assume first element is now a registered name
+            name = parts.get(0);
+            parts.remove(0);
+
+            if (!parts.isEmpty()) {
+                // Name is removed, so check if the first element is now an identifier
+                ArbitraryResourceStatus status = this.getStatus(service, name, parts.get(0), false);
+                if (status.getTotalChunkCount() > 0) {
+                    // Matched service, name and identifier combination - so assume this is an identifier and can be removed
+                    identifier = parts.get(0);
+                    parts.remove(0);
+                    prefixParts.add(identifier);
+                }
+            }
+
+            if (!parts.isEmpty()) {
+                // outPath can be built by combining any remaining parts
+                outPath = String.join("/", parts);
+            }
+        }
+
+        String prefix = StringUtils.join(prefixParts, "/");
+        if (prefix != null && !prefix.isEmpty()) {
+            prefix = "/" + prefix;
+        }
+
+        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(name, ResourceIdType.NAME, service, identifier, outPath,
+                secret58, prefix, includeResourceIdInPrefix, async, qdnContext, request, response, context);
         return renderer.render();
     }
 

src/main/java/org/qortal/api/model/AccountPenaltyStats.java

@@ -2,11 +2,9 @@ package org.qortal.api.model;
 
 import org.qortal.block.SelfSponsorshipAlgoV1Block;
 import org.qortal.data.account.AccountData;
-import org.qortal.data.naming.NameData;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlElement;
 import java.util.ArrayList;
 import java.util.List;
 

src/main/java/org/qortal/api/model/ActivitySummary.java

@@ -1,15 +1,14 @@
 package org.qortal.api.model;
 
-import java.util.Collections;
-import java.util.EnumMap;
-import java.util.Map;
+import org.qortal.api.TransactionCountMapXmlAdapter;
+import org.qortal.transaction.Transaction.TransactionType;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
-
-import org.qortal.api.TransactionCountMapXmlAdapter;
-import org.qortal.transaction.Transaction.TransactionType;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.Map;
 
 @XmlAccessorType(XmlAccessType.FIELD)
 public class ActivitySummary {

src/main/java/org/qortal/api/model/AggregatedOrder.java

@@ -1,13 +1,13 @@
 package org.qortal.api.model;
 
+import org.qortal.data.asset.OrderData;
+
 import javax.xml.bind.Marshaller;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import org.qortal.data.asset.OrderData;
-
 @XmlAccessorType(XmlAccessType.NONE)
 public class AggregatedOrder {
 

src/main/java/org/qortal/api/model/ApiOnlineAccount.java

@@ -1,7 +1,13 @@
 package org.qortal.api.model;
 
+import org.qortal.account.Account;
+import org.qortal.repository.DataException;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.repository.Repository;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
 
 // All properties to be converted to JSON via JAXB
 @XmlAccessorType(XmlAccessType.FIELD)
@@ -47,4 +53,31 @@ public class ApiOnlineAccount {
 		return this.recipientAddress;
 	}
 
+	public int getMinterLevelFromPublicKey() {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			return Account.getRewardShareEffectiveMintingLevel(repository, this.rewardSharePublicKey);
+		} catch (DataException e) {
+			return 0;
+		}
+	}
+
+	public boolean getIsMember() {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			return repository.getGroupRepository().memberExists(694, getMinterAddress());
+		} catch (DataException e) {
+			return false;
+		}
+	}
+
+	// JAXB special
+	
+	@XmlElement(name = "minterLevel")
+	protected int getMinterLevel() {
+		return getMinterLevelFromPublicKey();
+	}
+
+	@XmlElement(name = "isMinterMember")
+	protected boolean getMinterMember() {
+		return getIsMember();
+	}
 }

src/main/java/org/qortal/api/model/AtCreationRequest.java

@@ -0,0 +1,101 @@
+package org.qortal.api.model;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.DecoderException;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlTransient;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class AtCreationRequest {
+
+    @Schema(description = "CIYAM AT version", example = "2")
+    private short ciyamAtVersion;
+
+    @Schema(description = "base64-encoded code bytes", example = "")
+    private String codeBytesBase64;
+
+    @Schema(description = "base64-encoded data bytes", example = "")
+    private String dataBytesBase64;
+
+    private short numCallStackPages;
+    private short numUserStackPages;
+    private long minActivationAmount;
+
+    // Default constructor for JSON deserialization
+    public AtCreationRequest() {}
+
+    // Getters and setters
+    public short getCiyamAtVersion() {
+        return ciyamAtVersion;
+    }
+
+    public void setCiyamAtVersion(short ciyamAtVersion) {
+        this.ciyamAtVersion = ciyamAtVersion;
+    }
+
+
+    public String getCodeBytesBase64() {
+        return this.codeBytesBase64;
+    }
+
+    @XmlTransient
+    @Schema(hidden = true)
+    public byte[] getCodeBytes() {
+        if (this.codeBytesBase64 != null) {
+            try {
+                return Base64.decode(this.codeBytesBase64);
+            }
+            catch (DecoderException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+
+    public String getDataBytesBase64() {
+        return this.dataBytesBase64;
+    }
+
+    @XmlTransient
+    @Schema(hidden = true)
+    public byte[] getDataBytes() {
+        if (this.dataBytesBase64 != null) {
+            try {
+                return Base64.decode(this.dataBytesBase64);
+            }
+            catch (DecoderException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+
+    public short getNumCallStackPages() {
+        return numCallStackPages;
+    }
+
+    public void setNumCallStackPages(short numCallStackPages) {
+        this.numCallStackPages = numCallStackPages;
+    }
+
+    public short getNumUserStackPages() {
+        return numUserStackPages;
+    }
+
+    public void setNumUserStackPages(short numUserStackPages) {
+        this.numUserStackPages = numUserStackPages;
+    }
+
+    public long getMinActivationAmount() {
+        return minActivationAmount;
+    }
+
+    public void setMinActivationAmount(long minActivationAmount) {
+        this.minActivationAmount = minActivationAmount;
+    }
+}

src/main/java/org/qortal/api/model/BlockMintingInfo.java

@@ -9,6 +9,7 @@ import java.math.BigInteger;
 public class BlockMintingInfo {
 
 	public byte[] minterPublicKey;
+	public String minterAddress;
 	public int minterLevel;
 	public int onlineAccountsCount;
 	public BigDecimal maxDistance;
@@ -19,5 +20,4 @@ public class BlockMintingInfo {
 
 	public BlockMintingInfo() {
 	}
-
 }

src/main/java/org/qortal/api/model/BlockSignerSummary.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import org.qortal.crypto.Crypto;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import org.qortal.crypto.Crypto;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class BlockSignerSummary {
 

src/main/java/org/qortal/api/model/ConnectedPeer.java

@@ -17,7 +17,7 @@ public class ConnectedPeer {
 
     public enum Direction {
         INBOUND,
-        OUTBOUND;
+        OUTBOUND
     }
 
     public Direction direction;

src/main/java/org/qortal/api/model/CrossChainBitcoinRedeemRequest.java

@@ -1,11 +1,10 @@
 package org.qortal.api.model;
 
-import java.math.BigDecimal;
+import io.swagger.v3.oas.annotations.media.Schema;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
-
-import io.swagger.v3.oas.annotations.media.Schema;
+import java.math.BigDecimal;
 
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainBitcoinRedeemRequest {

src/main/java/org/qortal/api/model/CrossChainBitcoinRefundRequest.java

@@ -1,11 +1,10 @@
 package org.qortal.api.model;
 
-import java.math.BigDecimal;
+import io.swagger.v3.oas.annotations.media.Schema;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
-
-import io.swagger.v3.oas.annotations.media.Schema;
+import java.math.BigDecimal;
 
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainBitcoinRefundRequest {

src/main/java/org/qortal/api/model/CrossChainBitcoinTemplateRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainBitcoinTemplateRequest {
 

src/main/java/org/qortal/api/model/CrossChainBitcoinyHTLCStatus.java

@@ -1,11 +1,10 @@
 package org.qortal.api.model;
 
-import java.math.BigDecimal;
+import io.swagger.v3.oas.annotations.media.Schema;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
-
-import io.swagger.v3.oas.annotations.media.Schema;
+import java.math.BigDecimal;
 
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainBitcoinyHTLCStatus {

src/main/java/org/qortal/api/model/CrossChainBuildRequest.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainBuildRequest {
 

src/main/java/org/qortal/api/model/CrossChainCancelRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainCancelRequest {
 

src/main/java/org/qortal/api/model/CrossChainOfferSummary.java

@@ -1,14 +1,13 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.crosschain.AcctMode;
+import org.qortal.data.crosschain.CrossChainTradeData;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import org.qortal.crosschain.AcctMode;
-import org.qortal.data.crosschain.CrossChainTradeData;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
 // All properties to be converted to JSON via JAXB
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainOfferSummary {

src/main/java/org/qortal/api/model/CrossChainSecretRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainSecretRequest {
 

src/main/java/org/qortal/api/model/CrossChainTradeLedgerEntry.java

@@ -0,0 +1,72 @@
+package org.qortal.api.model;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.data.crosschain.CrossChainTradeData;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+// All properties to be converted to JSON via JAXB
+@XmlAccessorType(XmlAccessType.FIELD)
+public class CrossChainTradeLedgerEntry {
+
+	private String market;
+
+	private String currency;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long quantity;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long feeAmount;
+
+	private String feeCurrency;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long totalPrice;
+
+	private long tradeTimestamp;
+
+	protected CrossChainTradeLedgerEntry() {
+		/* For JAXB */
+	}
+
+	public CrossChainTradeLedgerEntry(String market, String currency, long quantity, long feeAmount, String feeCurrency, long totalPrice, long tradeTimestamp) {
+		this.market = market;
+		this.currency = currency;
+		this.quantity = quantity;
+		this.feeAmount = feeAmount;
+		this.feeCurrency = feeCurrency;
+		this.totalPrice = totalPrice;
+		this.tradeTimestamp = tradeTimestamp;
+	}
+
+	public String getMarket() {
+		return market;
+	}
+
+	public String getCurrency() {
+		return currency;
+	}
+
+	public long getQuantity() {
+		return quantity;
+	}
+
+	public long getFeeAmount() {
+		return feeAmount;
+	}
+
+	public String getFeeCurrency() {
+		return feeCurrency;
+	}
+
+	public long getTotalPrice() {
+		return totalPrice;
+	}
+
+	public long getTradeTimestamp() {
+		return tradeTimestamp;
+	}
+}

src/main/java/org/qortal/api/model/CrossChainTradeRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainTradeRequest {
 

src/main/java/org/qortal/api/model/CrossChainTradeSummary.java

@@ -1,13 +1,12 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.data.crosschain.CrossChainTradeData;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import org.qortal.data.crosschain.CrossChainTradeData;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
 // All properties to be converted to JSON via JAXB
 @XmlAccessorType(XmlAccessType.FIELD)
 public class CrossChainTradeSummary {

src/main/java/org/qortal/api/model/DatasetStatus.java

@@ -0,0 +1,50 @@
+package org.qortal.api.model;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Objects;
+
+// All properties to be converted to JSON via JAXB
+@XmlAccessorType(XmlAccessType.FIELD)
+public class DatasetStatus {
+
+    private String name;
+
+    private long count;
+
+    public DatasetStatus() {}
+
+    public DatasetStatus(String name, long count) {
+        this.name = name;
+        this.count = count;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DatasetStatus that = (DatasetStatus) o;
+        return count == that.count && Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, count);
+    }
+
+    @Override
+    public String toString() {
+        return "DatasetStatus{" +
+                "name='" + name + '\'' +
+                ", count=" + count +
+                '}';
+    }
+}

src/main/java/org/qortal/api/model/FileProperties.java

@@ -0,0 +1,16 @@
+package org.qortal.api.model;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class FileProperties {
+
+	public String filename;
+	public String mimeType;
+	public Long size;
+
+	public FileProperties() {
+	}
+
+}

src/main/java/org/qortal/api/model/GroupMembers.java

@@ -1,12 +1,11 @@
 package org.qortal.api.model;
 
-import java.util.List;
+import io.swagger.v3.oas.annotations.media.Schema;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
-
-import io.swagger.v3.oas.annotations.media.Schema;
+import java.util.List;
 
 @Schema(description = "Group info, maybe including members")
 // All properties to be converted to JSON via JAX-RS

src/main/java/org/qortal/api/model/NameSummary.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model;
 
+import org.qortal.data.naming.NameData;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
 
-import org.qortal.data.naming.NameData;
-
 @XmlAccessorType(XmlAccessType.NONE)
 public class NameSummary {
 

src/main/java/org/qortal/api/model/NodeStatus.java

@@ -1,13 +1,13 @@
 package org.qortal.api.model;
 
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-
 import org.qortal.controller.Controller;
 import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.controller.Synchronizer;
 import org.qortal.network.Network;
 
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
 @XmlAccessorType(XmlAccessType.FIELD)
 public class NodeStatus {
 

src/main/java/org/qortal/api/model/PollVotes.java

@@ -0,0 +1,83 @@
+package org.qortal.api.model;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.data.voting.VoteOnPollData;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import java.util.List;
+
+@Schema(description = "Poll vote info, including voters")
+// All properties to be converted to JSON via JAX-RS
+@XmlAccessorType(XmlAccessType.FIELD)
+public class PollVotes {
+
+    @Schema(description = "List of individual votes")
+    @XmlElement(name = "votes")
+    public List<VoteOnPollData> votes;
+
+    @Schema(description = "Total number of votes")
+    public Integer totalVotes;
+
+    @Schema(description = "Total weight of votes")
+    public Integer totalWeight;
+
+    @Schema(description = "List of vote counts for each option")
+    public List<OptionCount> voteCounts;
+
+    @Schema(description = "List of vote weights for each option")
+    public List<OptionWeight> voteWeights;
+
+    // For JAX-RS
+    protected PollVotes() {
+    }
+
+    public PollVotes(List<VoteOnPollData> votes, Integer totalVotes, Integer totalWeight, List<OptionCount> voteCounts, List<OptionWeight> voteWeights) {
+        this.votes = votes;
+        this.totalVotes = totalVotes;
+        this.totalWeight = totalWeight;
+        this.voteCounts = voteCounts;
+        this.voteWeights = voteWeights;
+    }
+
+    @Schema(description = "Vote info")
+    // All properties to be converted to JSON via JAX-RS
+    @XmlAccessorType(XmlAccessType.FIELD)
+    public static class OptionCount {
+        @Schema(description = "Option name")
+        public String optionName;
+
+        @Schema(description = "Vote count")
+        public Integer voteCount;
+
+        // For JAX-RS
+        protected OptionCount() {
+        }
+
+        public OptionCount(String optionName, Integer voteCount) {
+            this.optionName = optionName;
+            this.voteCount = voteCount;
+        }
+    }
+
+    @Schema(description = "Vote weights")
+    // All properties to be converted to JSON via JAX-RS
+    @XmlAccessorType(XmlAccessType.FIELD)
+    public static class OptionWeight {
+        @Schema(description = "Option name")
+        public String optionName;
+
+        @Schema(description = "Vote weight")
+        public Integer voteWeight;
+
+        // For JAX-RS
+        protected OptionWeight() {
+        }
+
+        public OptionWeight(String optionName, Integer voteWeight) {
+            this.optionName = optionName;
+            this.voteWeight = voteWeight;
+        }
+    }
+}

src/main/java/org/qortal/api/model/RewardShareKeyRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class RewardShareKeyRequest {
 

src/main/java/org/qortal/api/model/SimpleForeignTransaction.java

@@ -1,13 +1,12 @@
 package org.qortal.api.model;
 
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class SimpleForeignTransaction {
 

src/main/java/org/qortal/api/model/SimpleTransactionSignRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class SimpleTransactionSignRequest {
 

src/main/java/org/qortal/api/model/TradeWithOrderInfo.java

@@ -1,14 +1,13 @@
 package org.qortal.api.model;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.data.asset.OrderData;
+import org.qortal.data.asset.TradeData;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
 
-import org.qortal.data.asset.OrderData;
-import org.qortal.data.asset.TradeData;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @Schema(description = "Asset trade, including order info")
 // All properties to be converted to JSON via JAX-RS
 @XmlAccessorType(XmlAccessType.FIELD)

src/main/java/org/qortal/api/model/crosschain/AddressRequest.java

@@ -0,0 +1,17 @@
+package org.qortal.api.model.crosschain;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class AddressRequest {
+
+	@Schema(description = "Litecoin BIP32 extended public key", example = "tpub___________________________________________________________________________________________________________")
+	public String xpub58;
+
+	public AddressRequest() {
+	}
+
+}

src/main/java/org/qortal/api/model/crosschain/BitcoinSendRequest.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class BitcoinSendRequest {
 

src/main/java/org/qortal/api/model/crosschain/BitcoinyTBDRequest.java

@@ -0,0 +1,692 @@
+package org.qortal.api.model.crosschain;
+
+import org.qortal.crosschain.ServerInfo;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Arrays;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class BitcoinyTBDRequest {
+
+    /**
+     * Target Timespan
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nPowTargetTimespan
+     */
+    private int targetTimespan;
+
+    /**
+     * Target Spacing
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nPowTargetSpacing
+     */
+    private int targetSpacing;
+
+    /**
+     * Packet Magic
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in pchMessageStart, then convert the hex to decimal.
+     *
+     * Ex. litecoin
+     * pchMessageStart[0] = 0xfb;
+     * pchMessageStart[1] = 0xc0;
+     * pchMessageStart[2] = 0xb6;
+     * pchMessageStart[3] = 0xdb;
+     * packetMagic = 0xfbc0b6db = 4223710939
+     */
+    private long packetMagic;
+
+    /**
+     * Port
+     *
+     * extracted from /src/chainparams.cpp class
+     * nDefaultPort
+     */
+    private int port;
+
+    /**
+     * Address Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[PUBKEY_ADDRESS] from Main Network
+     */
+    private int addressHeader;
+
+    /**
+     * P2sh Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[SCRIPT_ADDRESS] from Main Network
+     */
+    private int p2shHeader;
+
+    /**
+     * Segwit Address Hrp
+     *
+     * HRP -> Human Readable Parts
+     *
+     * extracted from /src/chainparams.cpp class
+     * bech32_hrp
+     */
+    private String segwitAddressHrp;
+
+    /**
+     * Dumped Private Key Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[SECRET_KEY] from Main Network
+     * This is usually, but not always ... addressHeader + 128
+     */
+    private int dumpedPrivateKeyHeader;
+
+    /**
+     * Subsidy Decreased Block Count
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nSubsidyHalvingInterval
+     *
+     * Digibyte does not support this, because they do halving differently.
+     */
+    private int subsidyDecreaseBlockCount;
+
+    /**
+     * Expected Genesis Hash
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.hashGenesisBlock
+     * Remove '0x' prefix
+     */
+    private String expectedGenesisHash;
+
+    /**
+     * Common Script Pub Key
+     *
+     * extracted from /src/chainparams.cpp class
+     * This is the key commonly used to sign alerts for altcoins. Bitcoin and Digibyte are know exceptions.
+     */
+    public static final String SCRIPT_PUB_KEY = "040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9";
+
+    /**
+     * The Script Pub Key
+     *
+     * extracted from /src/chainparams.cpp class
+     * The key to sign alerts.
+     *
+     * const CScript genesisOutputScript = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
+     *
+     * ie LTC = 040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9
+     *
+     * this may be the same value as scripHex
+     */
+    private String pubKey;
+
+    /**
+     * DNS Seeds
+     *
+     * extracted from /src/chainparams.cpp class
+     * vSeeds
+     */
+    private String[] dnsSeeds;
+
+    /**
+     * BIP32 Header P2PKH Pub
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_PUBLIC_KEY]
+     * base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E} = 0x0488B21E
+     */
+    private int bip32HeaderP2PKHpub;
+
+    /**
+     * BIP32 Header P2PKH Priv
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_SECRET_KEY]
+     * base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4} = 0x0488ADE4
+     */
+    private int bip32HeaderP2PKHpriv;
+
+    /**
+     * Address Header (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[PUBKEY_ADDRESS] from Testnet
+     */
+    private int addressHeaderTestnet;
+
+    /**
+     * BIP32 Header P2PKH Pub (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_PUBLIC_KEY]
+     * base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E} = 0x0488B21E
+     */
+    private int bip32HeaderP2PKHpubTestnet;
+
+    /**
+     * BIP32 Header P2PKH Priv (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_SECRET_KEY]
+     * base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4} = 0x0488ADE4
+     */
+    private int bip32HeaderP2PKHprivTestnet;
+
+    /**
+     * Id
+     *
+     * "org.litecoin.production" for LTC
+     * I'm guessing this just has to match others for trading purposes.
+     */
+    private String id;
+
+    /**
+     * Majority Enforce Block Upgrade
+     *
+     * All coins are setting this to 750, except DOGE is setting this to 1500.
+     */
+    private int majorityEnforceBlockUpgrade;
+
+    /**
+     * Majority Reject Block Outdated
+     *
+     * All coins are setting this to 950, except DOGE is setting this to 1900.
+     */
+    private int majorityRejectBlockOutdated;
+
+    /**
+     * Majority Window
+     *
+     * All coins are setting this to 1000, except DOGE is setting this to 2000.
+     */
+    private int majorityWindow;
+
+    /**
+     * Code
+     *
+     * "LITE" for LTC
+     * Currency code for full unit.
+     */
+    private String code;
+
+    /**
+     * mCode
+     *
+     * "mLITE" for LTC
+     * Currency code for milli unit.
+     */
+    private String mCode;
+
+    /**
+     * Base Code
+     *
+     * "Liteoshi" for LTC
+     * Currency code for base unit.
+     */
+    private String baseCode;
+
+    /**
+     * Min Non Dust Output
+     *
+     * 100000 for LTC, web search for minimum transaction fee per kB
+     */
+    private int minNonDustOutput;
+
+    /**
+     * URI Scheme
+     *
+     * uriScheme = "litecoin" for LTC
+     * Do a web search to find this value.
+     */
+    private String uriScheme;
+
+    /**
+     * Protocol Version Minimum
+     *
+     * 70002 for LTC
+     * extracted from /src/protocol.h class
+     */
+    private int protocolVersionMinimum;
+
+    /**
+     * Protocol Version Current
+     *
+     * 70003 for LTC
+     * extracted from /src/protocol.h class
+     */
+    private int protocolVersionCurrent;
+
+    /**
+     * Has Max Money
+     *
+     * false for DOGE, true for BTC and LTC
+     */
+    private boolean hasMaxMoney;
+
+    /**
+     * Max Money
+     *
+     * 84000000 for LTC, 21000000 for BTC
+     * extracted from src/amount.h class
+     */
+    private long maxMoney;
+
+    /**
+     * Currency Code
+     *
+     * The trading symbol, ie LTC, BTC, DOGE
+     */
+    private String currencyCode;
+
+    /**
+     * Minimum Order Amount
+     *
+     * web search, LTC minimumOrderAmount = 1000000, 0.01 LTC minimum order to avoid dust errors
+     */
+    private long minimumOrderAmount;
+
+    /**
+     * Fee Per Kb
+     *
+     * web search, LTC feePerKb = 10000, 0.0001 LTC per 1000 bytes
+     */
+    private long feePerKb;
+
+    /**
+     * Network Name
+     *
+     * ie Litecoin-MAIN
+     */
+    private String networkName;
+
+    /**
+     * Fee Required
+     *
+     *  web search, LTC fee required = 1000L
+     */
+    private long feeRequired;
+
+    /**
+     * Extended Public Key
+     *
+     * xpub for operations that require wallet watching
+     */
+    private String extendedPublicKey;
+
+    /**
+     * Send Amount
+     *
+     * The amount to send in base units. Also, requires sending fee per byte, receiving address and sender's extended private key.
+     */
+    private long sendAmount;
+
+    /**
+     * Sending Fee Per Byte
+     *
+     * The fee to include on a send request in base units. Also, requires receiving address, sender's extended private key and send amount.
+     */
+    private long sendingFeePerByte;
+
+    /**
+     * Receiving Address
+     *
+     * The receiving address for a send request. Also, requires send amount, sender's extended private key and sending fee per byte.
+     */
+    private String receivingAddress;
+
+    /**
+     * Extended Private Key
+     *
+     * xpriv address for a send request. Also, requires receiving address, send amount and sending fee per byte.
+     */
+    private String extendedPrivateKey;
+
+    /**
+     * Server Info
+     *
+     * For adding, removing, setting current server requests.
+     */
+    private ServerInfo serverInfo;
+
+    /**
+     * Script Sig
+     *
+     * extracted from /src/chainparams.cpp class
+     * pszTimestamp
+     *
+     * transform this value - https://bitcoin.stackexchange.com/questions/13122/scriptsig-coinbase-structure-of-the-genesis-block
+     * ie LTC = 04ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536
+     * ie DOGE = 04ffff001d0104084e696e746f6e646f
+     */
+    private String scriptSig;
+
+    /**
+     * Script Hex
+     *
+     * extracted from /src/chainparams.cpp class
+     * genesisOutputScript
+     *
+     * ie LTC = 040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9
+     *
+     * this may be the same value as pubKey
+     */
+    private String scriptHex;
+
+    /**
+     * Reward
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(..., [reward] * COIN)
+     *
+     * ie LTC = 50, BTC = 50, DOGE = 88
+     */
+    private int reward;
+
+    /**
+     * Genesis Creation Version
+     */
+    private int genesisCreationVersion;
+
+    /**
+     * Genesis Block Version
+     */
+    private long genesisBlockVersion;
+
+    /**
+     * Genesis Time
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(nTime, ...)
+     *
+     * ie LTC = 1317972665
+     */
+    private long genesisTime;
+
+    /**
+     * Difficulty Target
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(genesisTime, nonce, difficultyTarget, 1, reward * COIN);
+     *
+     * convert from hex to decimal
+     *
+     * ie LTC = 0x1e0ffff0 = 504365040
+     */
+    private long difficultyTarget;
+
+    /**
+     * Merkle Hex
+     */
+    private String merkleHex;
+
+    /**
+     * Nonce
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(genesisTime, nonce, difficultyTarget, 1, reward * COIN);
+     *
+     * ie LTC = 2084524493
+     */
+    private long nonce;
+
+
+    public int getTargetTimespan() {
+        return targetTimespan;
+    }
+
+    public int getTargetSpacing() {
+        return targetSpacing;
+    }
+
+    public long getPacketMagic() {
+        return packetMagic;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public int getAddressHeader() {
+        return addressHeader;
+    }
+
+    public int getP2shHeader() {
+        return p2shHeader;
+    }
+
+    public String getSegwitAddressHrp() {
+        return segwitAddressHrp;
+    }
+
+    public int getDumpedPrivateKeyHeader() {
+        return dumpedPrivateKeyHeader;
+    }
+
+    public int getSubsidyDecreaseBlockCount() {
+        return subsidyDecreaseBlockCount;
+    }
+
+    public String getExpectedGenesisHash() {
+        return expectedGenesisHash;
+    }
+
+    public String getPubKey() {
+        return pubKey;
+    }
+
+    public String[] getDnsSeeds() {
+        return dnsSeeds;
+    }
+
+    public int getBip32HeaderP2PKHpub() {
+        return bip32HeaderP2PKHpub;
+    }
+
+    public int getBip32HeaderP2PKHpriv() {
+        return bip32HeaderP2PKHpriv;
+    }
+
+    public int getAddressHeaderTestnet() {
+        return addressHeaderTestnet;
+    }
+
+    public int getBip32HeaderP2PKHpubTestnet() {
+        return bip32HeaderP2PKHpubTestnet;
+    }
+
+    public int getBip32HeaderP2PKHprivTestnet() {
+        return bip32HeaderP2PKHprivTestnet;
+    }
+
+    public String getId() {
+        return  this.id;
+    }
+
+    public int getMajorityEnforceBlockUpgrade() {
+        return this.majorityEnforceBlockUpgrade;
+    }
+
+    public int getMajorityRejectBlockOutdated() {
+        return this.majorityRejectBlockOutdated;
+    }
+
+    public int getMajorityWindow() {
+        return this.majorityWindow;
+    }
+
+    public String getCode() {
+        return this.code;
+    }
+
+    public String getmCode() {
+        return this.mCode;
+    }
+
+    public String getBaseCode() {
+        return this.baseCode;
+    }
+
+    public int getMinNonDustOutput() {
+        return this.minNonDustOutput;
+    }
+
+    public String getUriScheme() {
+        return this.uriScheme;
+    }
+
+    public int getProtocolVersionMinimum() {
+        return this.protocolVersionMinimum;
+    }
+
+    public int getProtocolVersionCurrent() {
+        return this.protocolVersionCurrent;
+    }
+
+    public boolean isHasMaxMoney() {
+        return this.hasMaxMoney;
+    }
+
+    public long getMaxMoney() {
+        return this.maxMoney;
+    }
+
+    public String getCurrencyCode() {
+        return this.currencyCode;
+    }
+
+    public long getMinimumOrderAmount() {
+        return this.minimumOrderAmount;
+    }
+
+    public long getFeePerKb() {
+        return this.feePerKb;
+    }
+
+    public String getNetworkName() {
+        return this.networkName;
+    }
+
+    public long getFeeRequired() {
+        return this.feeRequired;
+    }
+
+    public String getExtendedPublicKey() {
+        return this.extendedPublicKey;
+    }
+
+    public long getSendAmount() {
+        return this.sendAmount;
+    }
+
+    public long getSendingFeePerByte() {
+        return this.sendingFeePerByte;
+    }
+
+    public String getReceivingAddress() {
+        return this.receivingAddress;
+    }
+
+    public String getExtendedPrivateKey() {
+        return this.extendedPrivateKey;
+    }
+
+    public ServerInfo getServerInfo() {
+        return this.serverInfo;
+    }
+
+    public String getScriptSig() {
+        return this.scriptSig;
+    }
+
+    public String getScriptHex() {
+        return this.scriptHex;
+    }
+
+    public int getReward() {
+        return this.reward;
+    }
+
+    public int getGenesisCreationVersion() {
+        return this.genesisCreationVersion;
+    }
+
+    public long getGenesisBlockVersion() {
+        return this.genesisBlockVersion;
+    }
+
+    public long getGenesisTime() {
+        return this.genesisTime;
+    }
+
+    public long getDifficultyTarget() {
+        return this.difficultyTarget;
+    }
+
+    public String getMerkleHex() {
+        return this.merkleHex;
+    }
+
+    public long getNonce() {
+        return this.nonce;
+    }
+
+    @Override
+    public String toString() {
+        return "BitcoinyTBDRequest{" +
+                "targetTimespan=" + targetTimespan +
+                ", targetSpacing=" + targetSpacing +
+                ", packetMagic=" + packetMagic +
+                ", port=" + port +
+                ", addressHeader=" + addressHeader +
+                ", p2shHeader=" + p2shHeader +
+                ", segwitAddressHrp='" + segwitAddressHrp + '\'' +
+                ", dumpedPrivateKeyHeader=" + dumpedPrivateKeyHeader +
+                ", subsidyDecreaseBlockCount=" + subsidyDecreaseBlockCount +
+                ", expectedGenesisHash='" + expectedGenesisHash + '\'' +
+                ", pubKey='" + pubKey + '\'' +
+                ", dnsSeeds=" + Arrays.toString(dnsSeeds) +
+                ", bip32HeaderP2PKHpub=" + bip32HeaderP2PKHpub +
+                ", bip32HeaderP2PKHpriv=" + bip32HeaderP2PKHpriv +
+                ", addressHeaderTestnet=" + addressHeaderTestnet +
+                ", bip32HeaderP2PKHpubTestnet=" + bip32HeaderP2PKHpubTestnet +
+                ", bip32HeaderP2PKHprivTestnet=" + bip32HeaderP2PKHprivTestnet +
+                ", id='" + id + '\'' +
+                ", majorityEnforceBlockUpgrade=" + majorityEnforceBlockUpgrade +
+                ", majorityRejectBlockOutdated=" + majorityRejectBlockOutdated +
+                ", majorityWindow=" + majorityWindow +
+                ", code='" + code + '\'' +
+                ", mCode='" + mCode + '\'' +
+                ", baseCode='" + baseCode + '\'' +
+                ", minNonDustOutput=" + minNonDustOutput +
+                ", uriScheme='" + uriScheme + '\'' +
+                ", protocolVersionMinimum=" + protocolVersionMinimum +
+                ", protocolVersionCurrent=" + protocolVersionCurrent +
+                ", hasMaxMoney=" + hasMaxMoney +
+                ", maxMoney=" + maxMoney +
+                ", currencyCode='" + currencyCode + '\'' +
+                ", minimumOrderAmount=" + minimumOrderAmount +
+                ", feePerKb=" + feePerKb +
+                ", networkName='" + networkName + '\'' +
+                ", feeRequired=" + feeRequired +
+                ", extendedPublicKey='" + extendedPublicKey + '\'' +
+                ", sendAmount=" + sendAmount +
+                ", sendingFeePerByte=" + sendingFeePerByte +
+                ", receivingAddress='" + receivingAddress + '\'' +
+                ", extendedPrivateKey='" + extendedPrivateKey + '\'' +
+                ", serverInfo=" + serverInfo +
+                ", scriptSig='" + scriptSig + '\'' +
+                ", scriptHex='" + scriptHex + '\'' +
+                ", reward=" + reward +
+                ", genesisCreationVersion=" + genesisCreationVersion +
+                ", genesisBlockVersion=" + genesisBlockVersion +
+                ", genesisTime=" + genesisTime +
+                ", difficultyTarget=" + difficultyTarget +
+                ", merkleHex='" + merkleHex + '\'' +
+                ", nonce=" + nonce +
+                '}';
+    }
+}

src/main/java/org/qortal/api/model/crosschain/DigibyteSendRequest.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class DigibyteSendRequest {
 

src/main/java/org/qortal/api/model/crosschain/LitecoinSendRequest.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class LitecoinSendRequest {
 

src/main/java/org/qortal/api/model/crosschain/RavencoinSendRequest.java

@@ -1,11 +1,11 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class RavencoinSendRequest {
 

src/main/java/org/qortal/api/model/crosschain/TradeBotCreateRequest.java

@@ -1,13 +1,12 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.crosschain.SupportedBlockchain;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
-import org.qortal.crosschain.SupportedBlockchain;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class TradeBotCreateRequest {
 

src/main/java/org/qortal/api/model/crosschain/TradeBotRespondRequest.java

@@ -1,10 +1,10 @@
 package org.qortal.api.model.crosschain;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
-import io.swagger.v3.oas.annotations.media.Schema;
-
 @XmlAccessorType(XmlAccessType.FIELD)
 public class TradeBotRespondRequest {
 

src/main/java/org/qortal/api/model/crosschain/TradeBotRespondRequests.java

@@ -0,0 +1,68 @@
+package org.qortal.api.model.crosschain;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import java.util.List;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class TradeBotRespondRequests {
+
+	@Schema(description = "Foreign blockchain private key, e.g. BIP32 'm' key for Bitcoin/Litecoin starting with 'xprv'",
+			example = "xprv___________________________________________________________________________________________________________")
+	public String foreignKey;
+
+	@Schema(description = "List of address matches")
+	@XmlElement(name = "addresses")
+	public List<String> addresses;
+
+	@Schema(description = "Qortal address for receiving QORT from AT", example = "Qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq")
+	public String receivingAddress;
+
+	public TradeBotRespondRequests() {
+	}
+
+	public TradeBotRespondRequests(String foreignKey, List<String> addresses, String receivingAddress) {
+		this.foreignKey = foreignKey;
+		this.addresses = addresses;
+		this.receivingAddress = receivingAddress;
+	}
+
+	@Schema(description = "Address Match")
+	// All properties to be converted to JSON via JAX-RS
+	@XmlAccessorType(XmlAccessType.FIELD)
+	public static class AddressMatch {
+		@Schema(description = "AT Address")
+		public String atAddress;
+
+		@Schema(description = "Receiving Address")
+		public String receivingAddress;
+
+		// For JAX-RS
+		protected AddressMatch() {
+		}
+
+		public AddressMatch(String atAddress, String receivingAddress) {
+			this.atAddress = atAddress;
+			this.receivingAddress = receivingAddress;
+		}
+
+		@Override
+		public String toString() {
+			return "AddressMatch{" +
+					"atAddress='" + atAddress + '\'' +
+					", receivingAddress='" + receivingAddress + '\'' +
+					'}';
+		}
+	}
+
+	@Override
+	public String toString() {
+		return "TradeBotRespondRequests{" +
+				"foreignKey='" + foreignKey + '\'' +
+				", addresses=" + addresses +
+				'}';
+	}
+}

src/main/java/org/qortal/api/proxy/resource/DevProxyServerResource.java

@@ -0,0 +1,174 @@
+package org.qortal.api.proxy.resource;
+
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiExceptionFactory;
+import org.qortal.api.HTMLParser;
+import org.qortal.arbitrary.misc.Service;
+import org.qortal.controller.DevProxyManager;
+
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.core.Context;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.ConnectException;
+import java.net.HttpURLConnection;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.util.Enumeration;
+
+
+@Path("/")
+public class DevProxyServerResource {
+
+    @Context HttpServletRequest request;
+    @Context HttpServletResponse response;
+    @Context ServletContext context;
+
+
+    @GET
+    public HttpServletResponse getProxyIndex() {
+        return this.proxy("/");
+    }
+
+    @GET
+    @Path("{path:.*}")
+    public HttpServletResponse getProxyPath(@PathParam("path") String inPath) {
+        return this.proxy(inPath);
+    }
+
+    private HttpServletResponse proxy(String inPath) {
+        try {
+            String source = DevProxyManager.getInstance().getSourceHostAndPort();
+
+            if (!inPath.startsWith("/")) {
+                inPath = "/" + inPath;
+            }
+
+            String queryString = request.getQueryString() != null ? "?" + request.getQueryString() : "";
+
+            // Open URL
+            URL url = new URL(String.format("http://%s%s%s", source, inPath, queryString));
+            HttpURLConnection con = (HttpURLConnection) url.openConnection();
+
+            // Proxy the request data
+            this.proxyRequestToConnection(request, con);
+
+            try {
+                // Make the request and proxy the response code
+                response.setStatus(con.getResponseCode());
+            }
+            catch (ConnectException e) {
+
+                // Tey converting localhost / 127.0.0.1 to IPv6 [::1]
+                if (source.startsWith("localhost") || source.startsWith("127.0.0.1")) {
+                    int port = 80;
+                    String[] parts = source.split(":");
+                    if (parts.length > 1) {
+                        port = Integer.parseInt(parts[1]);
+                    }
+                    source = String.format("[::1]:%d", port);
+                }
+
+                // Retry connection
+                url = new URL(String.format("http://%s%s%s", source, inPath, queryString));
+                con = (HttpURLConnection) url.openConnection();
+                this.proxyRequestToConnection(request, con);
+                response.setStatus(con.getResponseCode());
+            }
+
+            // Proxy the response data back to the caller
+            this.proxyConnectionToResponse(con, response, inPath);
+
+        } catch (IOException e) {
+            throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, e.getMessage());
+        }
+
+        return response;
+    }
+
+    private void proxyRequestToConnection(HttpServletRequest request, HttpURLConnection con) throws ProtocolException {
+        // Proxy the request method
+        con.setRequestMethod(request.getMethod());
+
+        // Proxy the request headers
+        Enumeration<String> headerNames = request.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String headerName = headerNames.nextElement();
+            String headerValue = request.getHeader(headerName);
+            con.setRequestProperty(headerName, headerValue);
+        }
+
+        // TODO: proxy any POST parameters from "request" to "con"
+    }
+
+    private void proxyConnectionToResponse(HttpURLConnection con, HttpServletResponse response, String inPath) throws IOException {
+        // Proxy the response headers
+        for (int i = 0; ; i++) {
+            String headerKey = con.getHeaderFieldKey(i);
+            String headerValue = con.getHeaderField(i);
+            if (headerKey != null && headerValue != null) {
+                response.addHeader(headerKey, headerValue);
+                continue;
+            }
+            break;
+        }
+
+        // Read the response body
+        InputStream inputStream = con.getInputStream();
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        byte[] buffer = new byte[4096];
+        int bytesRead;
+        while ((bytesRead = inputStream.read(buffer)) != -1) {
+            outputStream.write(buffer, 0, bytesRead);
+        }
+        byte[] data = outputStream.toByteArray(); // TODO: limit file size that can be read into memory
+
+        // Close the streams
+        outputStream.close();
+        inputStream.close();
+
+        // Extract filename
+        String filename = "";
+        if (inPath.contains("/")) {
+            String[] parts = inPath.split("/");
+            if (parts.length > 0) {
+                filename = parts[parts.length - 1];
+            }
+        }
+
+        String lang = request.getParameter("lang");
+        if (lang == null || lang.isBlank()) {
+            lang = "en"; // fallback
+        }
+
+        String theme = request.getParameter("theme");
+        if (theme == null || theme.isBlank()) {
+            theme = "light";
+        }
+
+        // Parse and modify output if needed
+        if (HTMLParser.isHtmlFile(filename)) {
+            // HTML file - needs to be parsed
+            HTMLParser htmlParser = new HTMLParser("", inPath, "", false, data, "proxy", Service.APP, null, theme , true, lang);
+            htmlParser.addAdditionalHeaderTags();
+            response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; media-src 'self' data: blob:; img-src 'self' data: blob:; connect-src 'self' ws:; font-src 'self' data:;");
+            response.setContentType(con.getContentType());
+            response.setContentLength(htmlParser.getData().length);
+            response.getOutputStream().write(htmlParser.getData());
+        }
+        else {
+            // Regular file - can be streamed directly
+            response.addHeader("Content-Security-Policy", "default-src 'self'");
+            response.setContentType(con.getContentType());
+            response.setContentLength(data.length);
+            response.getOutputStream().write(data);
+        }
+    }
+
+}

src/main/java/org/qortal/api/resource/AddressesResource.java

@@ -1,5 +1,6 @@
 package org.qortal.api.resource;
 
+import com.google.common.primitives.Bytes;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.ArraySchema;
@@ -9,25 +10,9 @@ import io.swagger.v3.oas.annotations.parameters.RequestBody;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.*;
-import javax.ws.rs.core.Context;
-import javax.ws.rs.core.MediaType;
-
 import org.qortal.account.Account;
 import org.qortal.account.PrivateKeyAccount;
-import org.qortal.api.ApiError;
-import org.qortal.api.ApiErrors;
-import org.qortal.api.ApiException;
-import org.qortal.api.ApiExceptionFactory;
-import org.qortal.api.Security;
+import org.qortal.api.*;
 import org.qortal.api.model.AccountPenaltyStats;
 import org.qortal.api.model.ApiOnlineAccount;
 import org.qortal.api.model.RewardShareKeyRequest;
@@ -35,9 +20,7 @@ import org.qortal.asset.Asset;
 import org.qortal.controller.LiteNode;
 import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.crypto.Crypto;
-import org.qortal.data.account.AccountData;
-import org.qortal.data.account.AccountPenaltyData;
-import org.qortal.data.account.RewardShareData;
+import org.qortal.data.account.*;
 import org.qortal.data.network.OnlineAccountData;
 import org.qortal.data.network.OnlineAccountLevel;
 import org.qortal.data.transaction.PublicizeTransactionData;
@@ -59,7 +42,16 @@ import org.qortal.transform.transaction.TransactionTransformer;
 import org.qortal.utils.Amounts;
 import org.qortal.utils.Base58;
 
-import com.google.common.primitives.Bytes;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.*;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Path("/addresses")
 @Tag(name = "Addresses")
@@ -240,8 +232,7 @@ public class AddressesResource {
 					}
 
 				} catch (DataException e) {
-					continue;
-				}
+                }
 			}
 
 			// Sort by level
@@ -335,11 +326,8 @@ public class AddressesResource {
 			)
 		}
 	)
-	@ApiErrors({ApiError.INVALID_PUBLIC_KEY, ApiError.NON_PRODUCTION, ApiError.REPOSITORY_ISSUE})
+	@ApiErrors({ApiError.INVALID_PUBLIC_KEY, ApiError.REPOSITORY_ISSUE})
 	public String fromPublicKey(@PathParam("publickey") String publicKey58) {
-		if (Settings.getInstance().isApiRestricted())
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.NON_PRODUCTION);
-
 		// Decode public key
 		byte[] publicKey;
 		try {
@@ -638,4 +626,160 @@ public class AddressesResource {
 		}
 	}
 
-}
+	@GET
+	@Path("/sponsorship/{address}")
+	@Operation(
+			summary = "Returns sponsorship statistics for an account",
+			description = "Returns sponsorship statistics for an account, excluding the recipients that get real reward shares",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = SponsorshipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public SponsorshipReport getSponsorshipReport(
+			@PathParam("address") String address,
+			@QueryParam(("realRewardShareRecipient")) String[] realRewardShareRecipients) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			SponsorshipReport report = repository.getAccountRepository().getSponsorshipReport(address, realRewardShareRecipients);
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			return report;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/sponsorship/{address}/sponsor")
+	@Operation(
+			summary = "Returns sponsorship statistics for an account's sponsor",
+			description = "Returns sponsorship statistics for an account's sponsor, excluding the recipients that get real reward shares",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = SponsorshipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public SponsorshipReport getSponsorshipReportForSponsor(
+			@PathParam("address") String address,
+			@QueryParam("realRewardShareRecipient") String[] realRewardShareRecipients) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get sponsor
+			Optional<String> sponsor = repository.getAccountRepository().getSponsor(address);
+
+			// if there is not sponsor, throw error
+			if(sponsor.isEmpty()) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			// get report for sponsor
+			SponsorshipReport report = repository.getAccountRepository().getSponsorshipReport(sponsor.get(), realRewardShareRecipients);
+
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			return report;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/mintership/{address}")
+	@Operation(
+			summary = "Returns mintership statistics for an account",
+			description = "Returns mintership statistics for an account",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = MintershipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public MintershipReport getMintershipReport(@PathParam("address") String address,
+												@QueryParam("realRewardShareRecipient") String[] realRewardShareRecipients ) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get sponsorship report for minter, fetch a list of one minter
+			SponsorshipReport report = repository.getAccountRepository().getMintershipReport(address, account -> List.of(account));
+
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			// since the report is for one minter, must get sponsee count separately
+			int sponseeCount = repository.getAccountRepository().getSponseeAddresses(address, realRewardShareRecipients).size();
+
+			// since the report is for one minter, must get the first name from a array of names that should be size 1
+			String name = report.getNames().length > 0 ? report.getNames()[0] : null;
+
+			// transform sponsorship report to mintership report
+			MintershipReport mintershipReport
+				= new MintershipReport(
+					report.getAddress(),
+					report.getLevel(),
+					report.getBlocksMinted(),
+					report.getAdjustments(),
+					report.getPenalties(),
+					report.isTransfer(),
+					name,
+					sponseeCount,
+					report.getAvgBalance(),
+					report.getArbitraryCount(),
+					report.getTransferAssetCount(),
+					report.getTransferPrivsCount(),
+					report.getSellCount(),
+					report.getSellAmount(),
+					report.getBuyCount(),
+					report.getBuyAmount()
+			);
+
+			return mintershipReport;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/levels/{minLevel}")
+	@Operation(
+			summary = "Return accounts with levels greater than or equal to input",
+			responses = {
+					@ApiResponse(
+							description = "online accounts",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, array = @ArraySchema(schema = @Schema(implementation = AddressLevelPairing.class)))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+
+	public List<AddressLevelPairing> getAddressLevelPairings(@PathParam("minLevel") int minLevel) {
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get the level address pairings
+			List<AddressLevelPairing> pairings = repository.getAccountRepository().getAddressLevelPairings(minLevel);
+
+			return pairings;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+}

src/main/java/org/qortal/api/resource/AnnotationPostProcessor.java

@@ -13,12 +13,6 @@ import io.swagger.v3.oas.models.media.MediaType;
 import io.swagger.v3.oas.models.media.Schema;
 import io.swagger.v3.oas.models.parameters.Parameter;
 import io.swagger.v3.oas.models.responses.ApiResponse;
-
-import java.lang.reflect.Method;
-import java.util.Locale;
-
-import javax.ws.rs.Path;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.api.ApiError;
@@ -27,6 +21,10 @@ import org.qortal.api.ApiErrors;
 import org.qortal.api.ApiService;
 import org.qortal.globalization.Translator;
 
+import javax.ws.rs.Path;
+import java.lang.reflect.Method;
+import java.util.Locale;
+
 public class AnnotationPostProcessor implements ReaderListener {
 
 	private static final Logger LOGGER = LogManager.getLogger(AnnotationPostProcessor.class);

src/main/java/org/qortal/api/resource/ApiDefinition.java

@@ -9,7 +9,6 @@ import io.swagger.v3.oas.annotations.info.Info;
 import io.swagger.v3.oas.annotations.security.SecurityScheme;
 import io.swagger.v3.oas.annotations.security.SecuritySchemes;
 import io.swagger.v3.oas.annotations.tags.Tag;
-
 import org.qortal.api.Security;
 
 @OpenAPIDefinition(