AaronFeickert
commented
10 months ago It's likely a better idea to create a ClaimProof class that handles the (de)serialization.
Open AaronFeickert opened 10 months ago
AaronFeickert
commented
10 months ago It's likely a better idea to create a ClaimProof class that handles the (de)serialization.
AaronFeickert
commented
9 months ago Added basic tests.
reubenyap
commented
8 months ago @coderabbitai review
coderabbitai[bot]
commented
8 months ago [!IMPORTANT]
Auto Review Skipped
Draft detected.
Please check the settings in the CodeRabbit UI or the
.coderabbit.yamlfile in this repository. To trigger a single review, invoke the@coderabbitai reviewcommand.You can disable this status message by setting the
reviews.review_statustofalsein the CodeRabbit configuration file.
The recent updates introduce a new Claim class within the libspark library, enhancing its cryptographic protocol capabilities. This class is pivotal for creating, proving, and verifying claims, particularly in the context of spend transactions. It encapsulates the necessary functionality for handling claims, including challenge generation, claim proof creation, and proof verification. These changes are spread across the Makefile, libspark, and test files, indicating a comprehensive integration of the new claim processing features.
| Files | Change Summaries |
|---|---|
src/Makefile.am |
Added claim.h and claim.cpp to libspark sources. |
src/libspark/claim.cpp, claim.h |
Introduced Claim class for creating, proving, and verifying claims. |
src/libspark/spend_transaction.cpp, spend_transaction.h |
Added proveClaim and verifyClaim methods to SpendTransaction class for claim processing. |
src/libspark/test/spend_transaction_test.cpp |
Enhanced testing for claim generation and verification in spend transactions. |
src/libspark/util.h |
Added LABEL_TRANSCRIPT_CLAIM constant. |
🐰✨
In the realm of code, where the bits align,
A new class emerges, its design so fine.
With claims to prove, and proofs to verify,
Thelibsparklibrary, now soaring high.
Through tests and transactions, it weaves its tale,
A cryptographic journey, where none shall fail.
🌟🐾
Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media?
This PR is an initial draft of a design for spend transaction claims.
A claim is a proof against an existing spend transaction that asserts the prover knew the spend key used to authorize the transaction. It also binds an arbitrary message into the proof, which can be useful to avoid replay. It has the same structure as a
ChaumProof, which is how it is internally represented (but it uses domain separation to ensure it can't be replayed for transaction authorization).How this should be structured in the codebase is up for debate. Because a claim is structured like a Chaum authorizing proof, it uses the same
ChaumProofdata structure and serialization. It is generated and verified using the staticSpendTransaction::proveClaimandSpendTransaction::verifyClaimfunctions.The prover must provide the spend transaction, the (secret) input coin data representing the coins that were consumed in the spend transaction, its full view and spend keys, an arbitrary message, and an identifier that the verifier can use to obtain its own view of the spend transaction.
The verifier must provide the proof, spend transaction, arbitrary message, and identifier. It is very important that the verifier use its own view of the spend transaction! Otherwise, the prover could lie about its contents.
Once the prover produces the
ChaumProofdata structure representing the claim, it should be sent to the verifier in a serialized package containing:ChaumProofThe verifier then uses its view of the ledger to look up the spend transaction using the identifier. It checks that the message is as expected. Then, it verifies the claim by checking the
ChaumProofwhile binding in the identifier and message.Summary by CodeRabbit
libsparklibrary to include functionality for creating, proving, and verifying claims in cryptographic protocols.