present_delegated.clsp

;; Copyright 2026 Julia.Social, Inc.
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;;     http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.

(mod (curried-args solution)

  (include *standard-cl-26*)
  (defun print (l x) (i (all "$print$" l x) x x))

  ; Handles presentation of credentials delegated through a chain of DIDs.  Verifies the
  ; delegation chain from the original issuer through intermediate delegators, ensuring each
  ; link authorized delegation of the specific claim.

  (include "condition_codes.clib")
  (include "sha256tree.clib")
  (include "curry_and_treehash.clib")
  (include "did_puzzles.clib")
  (include "jdid_announcements.clib")

  (embed-file present-claims-puzzlehash bin "present_claims.clsp.hash.bin")

  ; HACK: compiler bug forces this inefficient implementation of prepend
  (defun prepend-helper (fListA rListA listB)
    (c fListA (prepend-list rListA listB))
  )
  (defun prepend-list (listA listB)
    (if (l listA)
      (prepend-helper (f listA) (r listA) listB)
      listB
    )
  )

  (defun is-claim-in-list (claim-t-hash claim-treehash-list)
    (if (l claim-treehash-list)
      (if (= claim-t-hash (f claim-treehash-list))
        1
        (is-claim-in-list claim-t-hash (r claim-treehash-list))
      )
      0
    )
  )

  ; walks the delegation chain, verifying each delegator authorized the claim for the next link
  (defun process-delegations (curried-args
                              delegator-launcher-id 
                              claim-treehash 
                              delegations)
    (if (l delegations)
      (assign
          julia-DID-puzzlehash (f curried-args)
          my-launcher-id (f (r curried-args))
          curried-args-hash (sha256tree curried-args)

          current-delegation (f delegations)
          remaining-delegations (r delegations)

          delegatee-launcher-id (f current-delegation)
          delegation-list-reveal (f (r current-delegation))

          child-output (process-delegations curried-args 
                                            delegatee-launcher-id 
                                            claim-treehash 
                                            remaining-delegations)
          child-conditions (f child-output)
          last-subject-launcher-id (f (r child-output))
          
          announcement-message (jdidh-message delegatee-launcher-id
                                             (sha256 "sha256tree://./.julia-delegation")
                                             (sha256tree delegation-list-reveal)
                                             delegator-launcher-id
                                             0)
          my-coin-puzzlehash (julia-DID-coin-puzzlehash julia-DID-puzzlehash 
                                                        my-launcher-id 
                                                        curried-args-hash)
          output-condition (list ASSERT_PUZZLE_ANNOUNCEMENT (sha256 my-coin-puzzlehash announcement-message))

          output-conditions (c output-condition child-conditions)
          output (list output-conditions (if last-subject-launcher-id last-subject-launcher-id delegatee-launcher-id))

        (if (is-claim-in-list claim-treehash delegation-list-reveal)
          output
          (x 39)
        )
      )
      (list () ())
    )
  )

  ; asserts the original claim and delegation chain, then announces the delegated credential
  (defun construct-delegate-conditions (curried-args delegation-path)
    (assign
        julia-DID-puzzlehash (f curried-args)
        my-launcher-id (f (r curried-args))
        curried-args-hash (sha256tree curried-args)
        ( original-claim
          delegations
        ) delegation-path
        ( original-subject-did-launcher-id
          claim-property-hash
          claim-value-hash
          original-issuer-did-launcher-id
        ) original-claim
      (c (list ASSERT_PUZZLE_ANNOUNCEMENT (sha256 (julia-DID-coin-puzzlehash
                                                      julia-DID-puzzlehash
                                                      my-launcher-id
                                                      curried-args-hash)
                                                  (jdidh-message ; assert the original claim was valid
                                                    original-subject-did-launcher-id
                                                    claim-property-hash
                                                    claim-value-hash
                                                    original-issuer-did-launcher-id
                                                    1)))
         (c (list CREATE_PUZZLE_ANNOUNCEMENT (jdidv-message ; create a claim that we are the subject
                                               claim-property-hash
                                               claim-value-hash
                                               original-issuer-did-launcher-id))
            (assign
                delegation-output (process-delegations curried-args
                                                       original-subject-did-launcher-id 
                                                       (sha256tree (list
                                                         original-issuer-did-launcher-id
                                                         claim-property-hash
                                                         claim-value-hash))
                                                       delegations)
                conditions (f delegation-output)
                last-subject-launcher-id (f (r delegation-output))
              (if (= last-subject-launcher-id my-launcher-id)
                conditions
                (x 38)
              )
            )
         )
      )
    )
  )

  (defun process-subpuzzle (curried-args solution)
    (if (l solution)
      (if (= (sha256tree (f solution)) present-claims-puzzlehash)
        (f (r (a (f solution) (list curried-args (r solution)))))
        (x 37)
      )
      ()
    )
  )

  (defun construct-output (curried-args count solution)
    (if (> count 0)
      (prepend-list (construct-delegate-conditions curried-args (f solution))
                    (construct-output curried-args (- count 1) (r solution)))
      ; if we're done with conditions, run the subpuzzle
      (process-subpuzzle curried-args solution)
    )
  )

  ; solution format:
  ; count 
  ; delegations
  ; optional child-puzzle followed by its solution
  (list curried-args
        (construct-output curried-args (f solution) (r solution)))
)