A transparent and independently verifiable system designed to prove that trades existed before outcomes became known and that no trade data was modified, fabricated, replaced, or manipulated afterward.
Trade Data + Verification Salt ↓ SHA256 Hash ↓ Published Proof ↓ Independent Verification
Provable Trade Verification is a cryptographic integrity framework designed to provide transparency, accountability, and independently verifiable proof for automated trading activity.
Traditional trading systems require users to trust that published trade histories are genuine. However, without verifiable cryptographic proof, there is no reliable way to determine whether trades were added after outcomes became known, modified retroactively, or selectively hidden.
The Provable Trade system solves this problem by generating a deterministic SHA256 verification proof at the exact moment a trade opens. That proof is immediately published while sensitive trade details remain hidden. Once the trade closes, the original trade data and verification salt are revealed publicly, allowing anyone to independently reproduce the exact same SHA256 proof.
The system is built around a simple principle: users should not need to blindly trust the platform. Instead, users should be able to independently verify trade authenticity using publicly available cryptographic proofs.
Traditional trading platforms require users to trust that displayed trades are genuine and historically accurate.
SHA256 is a cryptographic hashing algorithm belonging to the SHA-2 family developed by the National Security Agency (NSA). It converts any input into a fixed-length 256-bit output represented as a hexadecimal string.
SHA256( Trade JSON Data + Verification Salt ) = Published Proof Hash
The same input always produces the exact same SHA256 hash across all devices, programming languages, and operating systems.
Even changing a single character in the original data produces a completely different hash.
Limited Information
Only public identifiers and the proof hash are visible while the trade remains active.
Full Verification Data
The original trade JSON data and verification salt are publicly revealed for independent verification.
Trades cannot be inserted after market outcomes become known because the proof hash already existed publicly beforehand.
Any modification to trade data changes the SHA256 hash immediately and invalidates verification.
Historical trade integrity becomes independently reproducible and mathematically verifiable.
Verification does not require trusting platform infrastructure or proprietary databases.
The verification process is intentionally transparent and independently reproducible. All verification calculations execute directly inside the user's browser.
The browser combines the revealed trade JSON data with the revealed verification salt.
A new SHA256 proof is generated locally using the reconstructed input data.
The generated hash is compared against the originally published proof hash.
The following JavaScript code is the actual verification logic used by the platform. This verification process executes entirely inside the user's browser and independently regenerates the SHA256 verification proof using the revealed trade data and verification salt. Users may inspect the verification source code directly using browser developer tools. Because verification occurs fully client-side, no server response is required to validate the verification result.
function sha256(message, callback){const msgBuffer =
new TextEncoder().encode(message);
crypto.subtle.digest('SHA-256', msgBuffer)
.then(function(hashBuffer){const hashArray =
Array.from(new Uint8Array(hashBuffer));
const hashHex =
hashArray
.map(function(b){return b
.toString(16)
.padStart(2, '0');
})
.join('');
callback(hashHex);
});
}sha256(tradeData + salt, function(generatedHash){if(generatedHash === publishedHash){console.log(
'Verification Successful'
);
}});Example of how proof hashes are generated and verified.
Users are not required to rely exclusively on the integrated browser verification system. The verification process is intentionally designed to be fully transparent, independently reproducible, and universally verifiable using any standard SHA256 implementation.
Because the verification proof is generated using publicly revealed trade data, a publicly revealed verification salt, and the deterministic SHA256 cryptographic hashing algorithm, any user can independently reproduce the verification result without relying on platform trust, proprietary infrastructure, or server-side validation.
Verification may be performed using any SHA256 generator, cryptographic tool, programming language, browser console, command-line utility, or external hashing library. If the generated SHA256 hash matches the originally published proof hash, the trade is mathematically confirmed as authentic and unmodified.
Copy the revealed trade JSON data exactly as displayed on the verification page.
The trade data must remain completely unchanged during verification. Even the smallest modification, formatting change, missing character, or whitespace difference will generate a different SHA256 hash result.
Copy the revealed verification salt and concatenate it directly after the trade JSON data.
The combined input must preserve the exact original order and formatting used during proof generation when the trade was initially created.
Generate a SHA256 cryptographic hash using the combined verification input.
Compare the generated SHA256 hash against the originally published proof hash. Matching results confirm that the trade existed before the outcome became known and that the verification data has not been modified, replaced, or fabricated.
The following tools may be used for independent SHA256 verification outside the platform environment.
Provable Trade verifies historical trade integrity and publication authenticity, but it does not guarantee trading performance, profitability, or financial outcomes.
The Provable Trade verification framework is designed specifically to provide cryptographic proof that trades were genuinely recorded before outcomes became known and that historical trade data has not been modified afterward. While the system significantly improves transparency and auditability, it is important to understand the scope and limitations of what the verification process actually guarantees.
Verification confirms the authenticity, integrity, and timing of published trades. It does not validate the quality of trading strategies, financial risk management, predictive accuracy, or future trading performance. Users should carefully distinguish between cryptographic integrity verification and financial performance evaluation.