lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

dispatch.rs (39167B)


      1 //! Each job has an isolated polling frame on the existing bounded worker.
      2 use super::*;
      3 use core::{future::Future, pin::Pin};
      4 
      5 pub(super) fn run<'a>(
      6     job: Job,
      7     kind: Kind,
      8     turn: stock::inventory::Turn<'a>,
      9 ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
     10     let stock::inventory::Turn {
     11         connection,
     12         namespace,
     13         selected: input,
     14         crypto,
     15         clock,
     16         uncertain,
     17     } = turn;
     18     match job {
     19         Job::ChangeStockGrant(change, proof, reply) => Box::pin(async move {
     20             let result = if kind == Kind::SellerStock && !*uncertain {
     21                 stock::grants::change(
     22                     &mut stock::inventory::Turn {
     23                         connection,
     24                         namespace,
     25                         selected: input,
     26                         crypto,
     27                         clock,
     28                         uncertain,
     29                     },
     30                     *change,
     31                     proof,
     32                 )
     33                 .await
     34             } else {
     35                 Err(WorkspaceError::RecoveryRequired)
     36             };
     37             let _ = reply.send(result);
     38         }),
     39         Job::ExecuteInventory(request, proof, reply) => Box::pin(async move {
     40             let result = if kind == Kind::SellerStock {
     41                 stock::inventory::Turn {
     42                     connection,
     43                     namespace,
     44                     selected: input,
     45                     crypto,
     46                     clock,
     47                     uncertain,
     48                 }
     49                 .create(*request, proof)
     50                 .await
     51             } else {
     52                 Err(OperationError::UnsupportedOperation)
     53             };
     54             let _ = reply.send(result);
     55         }),
     56         Job::InventoryOperation(binding, minimum, operation, digest, proof, reply) => {
     57             Box::pin(async move {
     58                 let result = if kind == Kind::SellerStock {
     59                     stock::inventory::Turn {
     60                         connection,
     61                         namespace,
     62                         selected: input,
     63                         crypto,
     64                         clock,
     65                         uncertain,
     66                     }
     67                     .creation(*binding, minimum, operation, digest, proof)
     68                     .await
     69                 } else {
     70                     Err(OperationError::UnsupportedOperation)
     71                 };
     72                 let _ = reply.send(result);
     73             })
     74         }
     75         Job::IssueStockConsent(binding, minimum, capture, proof, reply) => Box::pin(async move {
     76             let result = if kind == Kind::SellerStock {
     77                 stock::consent::issue(
     78                     &mut stock::inventory::Turn {
     79                         connection,
     80                         namespace,
     81                         selected: input,
     82                         crypto,
     83                         clock,
     84                         uncertain,
     85                     },
     86                     *binding,
     87                     minimum,
     88                     *capture,
     89                     proof,
     90                 )
     91                 .await
     92             } else {
     93                 Err(OperationError::UnsupportedOperation)
     94             };
     95             let _ = reply.send(result);
     96         }),
     97         Job::StockConsent(binding, minimum, operation, subject, proof, reply) => {
     98             Box::pin(async move {
     99                 let result = if kind == Kind::SellerStock {
    100                     stock::consent::query(
    101                         &mut stock::inventory::Turn {
    102                             connection,
    103                             namespace,
    104                             selected: input,
    105                             crypto,
    106                             clock,
    107                             uncertain,
    108                         },
    109                         *binding,
    110                         minimum,
    111                         operation,
    112                         subject,
    113                         proof,
    114                     )
    115                     .await
    116                 } else {
    117                     Err(OperationError::UnsupportedOperation)
    118                 };
    119                 let _ = reply.send(result);
    120             })
    121         }
    122         Job::RetainStockListing(binding, minimum, capture, proof, reply) => Box::pin(async move {
    123             let result = if kind == Kind::SellerStock {
    124                 stock::public_source::retain(
    125                     &mut stock::inventory::Turn {
    126                         connection,
    127                         namespace,
    128                         selected: input,
    129                         crypto,
    130                         clock,
    131                         uncertain,
    132                     },
    133                     *binding,
    134                     minimum,
    135                     *capture,
    136                     proof,
    137                 )
    138                 .await
    139             } else {
    140                 Err(OperationError::UnsupportedOperation)
    141             };
    142             let _ = reply.send(result);
    143         }),
    144         Job::StockListing(binding, minimum, lookup, proof, reply) => Box::pin(async move {
    145             let result = if kind == Kind::SellerStock {
    146                 stock::public_source::query(
    147                     &mut stock::inventory::Turn {
    148                         connection,
    149                         namespace,
    150                         selected: input,
    151                         crypto,
    152                         clock,
    153                         uncertain,
    154                     },
    155                     *binding,
    156                     minimum,
    157                     lookup,
    158                     proof,
    159                 )
    160                 .await
    161             } else {
    162                 Err(OperationError::UnsupportedOperation)
    163             };
    164             let _ = reply.send(result);
    165         }),
    166         Job::RetainStockSource(binding, minimum, capture, proof, reply) => Box::pin(async move {
    167             let result = if kind == Kind::SellerStock {
    168                 stock::source::retain(
    169                     &mut stock::inventory::Turn {
    170                         connection,
    171                         namespace,
    172                         selected: input,
    173                         crypto,
    174                         clock,
    175                         uncertain,
    176                     },
    177                     *binding,
    178                     minimum,
    179                     *capture,
    180                     proof,
    181                 )
    182                 .await
    183             } else {
    184                 Err(OperationError::UnsupportedOperation)
    185             };
    186             let _ = reply.send(result);
    187         }),
    188         Job::InstallStockAgreement(request, proof, reply) => Box::pin(async move {
    189             let result = if kind == Kind::SellerStock {
    190                 Box::pin(stock::inventory::installation::install(
    191                     &mut stock::inventory::Turn {
    192                         connection,
    193                         namespace,
    194                         selected: input,
    195                         crypto,
    196                         clock,
    197                         uncertain,
    198                     },
    199                     *request,
    200                     proof,
    201                 ))
    202                 .await
    203             } else {
    204                 Err(OperationError::UnsupportedOperation)
    205             };
    206             let _ = reply.send(result);
    207         }),
    208         Job::StockAgreementInstallation(request, proof, reply) => Box::pin(async move {
    209             let result = if kind == Kind::SellerStock {
    210                 Box::pin(stock::inventory::installation::read(
    211                     &mut stock::inventory::Turn {
    212                         connection,
    213                         namespace,
    214                         selected: input,
    215                         crypto,
    216                         clock,
    217                         uncertain,
    218                     },
    219                     *request,
    220                     proof,
    221                 ))
    222                 .await
    223             } else {
    224                 Err(OperationError::UnsupportedOperation)
    225             };
    226             let _ = reply.send(result);
    227         }),
    228         Job::AbortStockPreparation(request, proof, reply) => Box::pin(async move {
    229             let result = if kind == Kind::SellerStock {
    230                 Box::pin(stock::inventory::abort::abort(
    231                     &mut stock::inventory::Turn {
    232                         connection,
    233                         namespace,
    234                         selected: input,
    235                         crypto,
    236                         clock,
    237                         uncertain,
    238                     },
    239                     *request,
    240                     proof,
    241                 ))
    242                 .await
    243             } else {
    244                 Err(OperationError::UnsupportedOperation)
    245             };
    246             let _ = reply.send(result);
    247         }),
    248         Job::StockPreparationAbort(request, proof, reply) => Box::pin(async move {
    249             let result = if kind == Kind::SellerStock {
    250                 Box::pin(stock::inventory::abort::read(
    251                     &mut stock::inventory::Turn {
    252                         connection,
    253                         namespace,
    254                         selected: input,
    255                         crypto,
    256                         clock,
    257                         uncertain,
    258                     },
    259                     *request,
    260                     proof,
    261                 ))
    262                 .await
    263             } else {
    264                 Err(OperationError::UnsupportedOperation)
    265             };
    266             let _ = reply.send(result);
    267         }),
    268         Job::StockSnapshot(request, proof, reply) => Box::pin(async move {
    269             let result = if kind == Kind::SellerStock {
    270                 Box::pin(stock::snapshot::read(
    271                     &mut stock::inventory::Turn {
    272                         connection,
    273                         namespace,
    274                         selected: input,
    275                         crypto,
    276                         clock,
    277                         uncertain,
    278                     },
    279                     *request,
    280                     proof,
    281                 ))
    282                 .await
    283             } else {
    284                 Err(OperationError::UnsupportedOperation)
    285             };
    286             let _ = reply.send(result);
    287         }),
    288         Job::StockEvidencePage(request, after, proof, reply) => Box::pin(async move {
    289             let result = if kind == Kind::SellerStock {
    290                 Box::pin(stock::issuance::evidence::page(
    291                     &mut stock::inventory::Turn {
    292                         connection,
    293                         namespace,
    294                         selected: input,
    295                         crypto,
    296                         clock,
    297                         uncertain,
    298                     },
    299                     *request,
    300                     after,
    301                     proof,
    302                 ))
    303                 .await
    304             } else {
    305                 Err(OperationError::UnsupportedOperation)
    306             };
    307             let _ = reply.send(result);
    308         }),
    309         Job::CaptureStockUnissued(request, proof, reply) => Box::pin(async move {
    310             let result = if kind == Kind::SellerStock {
    311                 Box::pin(stock::issuance::unissued::capture(
    312                     &mut stock::inventory::Turn {
    313                         connection,
    314                         namespace,
    315                         selected: input,
    316                         crypto,
    317                         clock,
    318                         uncertain,
    319                     },
    320                     *request,
    321                     proof,
    322                 ))
    323                 .await
    324             } else {
    325                 Err(OperationError::UnsupportedOperation)
    326             };
    327             let _ = reply.send(result);
    328         }),
    329         Job::StockUnissued(request, proof, reply) => Box::pin(async move {
    330             let result = if kind == Kind::SellerStock {
    331                 Box::pin(stock::issuance::unissued::read(
    332                     &mut stock::inventory::Turn {
    333                         connection,
    334                         namespace,
    335                         selected: input,
    336                         crypto,
    337                         clock,
    338                         uncertain,
    339                     },
    340                     *request,
    341                     proof,
    342                 ))
    343                 .await
    344             } else {
    345                 Err(OperationError::UnsupportedOperation)
    346             };
    347             let _ = reply.send(result);
    348         }),
    349         Job::PrepareStockDelivery(request, proof, reply) => Box::pin(async move {
    350             let result = if kind == Kind::SellerStock {
    351                 Box::pin(stock::delivery::prepare(
    352                     &mut stock::inventory::Turn {
    353                         connection,
    354                         namespace,
    355                         selected: input,
    356                         crypto,
    357                         clock,
    358                         uncertain,
    359                     },
    360                     *request,
    361                     proof,
    362                 ))
    363                 .await
    364             } else {
    365                 Err(OperationError::UnsupportedOperation)
    366             };
    367             let _ = reply.send(result);
    368         }),
    369         Job::StockDeliveryAttempt(request, request_id, proof, reply) => Box::pin(async move {
    370             let result = if kind == Kind::SellerStock {
    371                 Box::pin(stock::delivery::query_attempt(
    372                     &mut stock::inventory::Turn {
    373                         connection,
    374                         namespace,
    375                         selected: input,
    376                         crypto,
    377                         clock,
    378                         uncertain,
    379                     },
    380                     *request,
    381                     request_id,
    382                     proof,
    383                 ))
    384                 .await
    385             } else {
    386                 Err(OperationError::UnsupportedOperation)
    387             };
    388             let _ = reply.send(result);
    389         }),
    390         Job::StockDeliverySummary(request, proof, reply) => Box::pin(async move {
    391             let result = if kind == Kind::SellerStock {
    392                 Box::pin(stock::delivery::summary(
    393                     &mut stock::inventory::Turn {
    394                         connection,
    395                         namespace,
    396                         selected: input,
    397                         crypto,
    398                         clock,
    399                         uncertain,
    400                     },
    401                     *request,
    402                     proof,
    403                 ))
    404                 .await
    405             } else {
    406                 Err(OperationError::UnsupportedOperation)
    407             };
    408             let _ = reply.send(result);
    409         }),
    410         Job::RecordStockDeliveryObservation(binding, proof, observation, reply) => {
    411             Box::pin(async move {
    412                 let result = if kind == Kind::SellerStock {
    413                     Box::pin(stock::delivery::capture_observation(
    414                         &mut stock::inventory::Turn {
    415                             connection,
    416                             namespace,
    417                             selected: input,
    418                             crypto,
    419                             clock,
    420                             uncertain,
    421                         },
    422                         *binding,
    423                         proof,
    424                         *observation,
    425                     ))
    426                     .await
    427                 } else {
    428                     Err(OperationError::UnsupportedOperation)
    429                 };
    430                 let _ = reply.send(result);
    431             })
    432         }
    433         Job::StockDeliveryObservations(request, after, proof, reply) => Box::pin(async move {
    434             let result = if kind == Kind::SellerStock {
    435                 Box::pin(stock::delivery::page(
    436                     &mut stock::inventory::Turn {
    437                         connection,
    438                         namespace,
    439                         selected: input,
    440                         crypto,
    441                         clock,
    442                         uncertain,
    443                     },
    444                     *request,
    445                     after,
    446                     proof,
    447                 ))
    448                 .await
    449             } else {
    450                 Err(OperationError::UnsupportedOperation)
    451             };
    452             let _ = reply.send(result);
    453         }),
    454         Job::CaptureStockEnvelope(request, proof, candidate, reply) => Box::pin(async move {
    455             let result = if kind == Kind::SellerStock {
    456                 Box::pin(stock::envelope::capture_obtained(
    457                     &mut stock::inventory::Turn {
    458                         connection,
    459                         namespace,
    460                         selected: input,
    461                         crypto,
    462                         clock,
    463                         uncertain,
    464                     },
    465                     request,
    466                     proof,
    467                     *candidate,
    468                 ))
    469                 .await
    470             } else {
    471                 Err(OperationError::UnsupportedOperation)
    472             };
    473             let _ = reply.send(result);
    474         }),
    475         Job::StockEnvelope(request, proof, reply) => Box::pin(async move {
    476             let result = if kind == Kind::SellerStock {
    477                 Box::pin(stock::envelope::read(
    478                     &mut stock::inventory::Turn {
    479                         connection,
    480                         namespace,
    481                         selected: input,
    482                         crypto,
    483                         clock,
    484                         uncertain,
    485                     },
    486                     *request,
    487                     proof,
    488                 ))
    489                 .await
    490             } else {
    491                 Err(OperationError::UnsupportedOperation)
    492             };
    493             let _ = reply.send(result);
    494         }),
    495         Job::StockRewrapAttempt(request, proof, reply) => Box::pin(async move {
    496             let result = if kind == Kind::SellerStock {
    497                 Box::pin(stock::envelope::rewrap_attempt(
    498                     &mut stock::inventory::Turn {
    499                         connection,
    500                         namespace,
    501                         selected: input,
    502                         crypto,
    503                         clock,
    504                         uncertain,
    505                     },
    506                     *request,
    507                     proof,
    508                 ))
    509                 .await
    510             } else {
    511                 Err(OperationError::UnsupportedOperation)
    512             };
    513             let _ = reply.send(result);
    514         }),
    515         Job::PrepareStockRewrap(request, proof, reply) => Box::pin(async move {
    516             let result = if kind == Kind::SellerStock {
    517                 Box::pin(stock::envelope::prepare_rewrap(
    518                     &mut stock::inventory::Turn {
    519                         connection,
    520                         namespace,
    521                         selected: input,
    522                         crypto,
    523                         clock,
    524                         uncertain,
    525                     },
    526                     *request,
    527                     proof,
    528                 ))
    529                 .await
    530             } else {
    531                 Err(OperationError::UnsupportedOperation)
    532             };
    533             let _ = reply.send(result);
    534         }),
    535         Job::StockRewraps(request, after, proof, reply) => Box::pin(async move {
    536             let result = if kind == Kind::SellerStock {
    537                 Box::pin(stock::envelope::page(
    538                     &mut stock::inventory::Turn {
    539                         connection,
    540                         namespace,
    541                         selected: input,
    542                         crypto,
    543                         clock,
    544                         uncertain,
    545                     },
    546                     *request,
    547                     after,
    548                     proof,
    549                 ))
    550                 .await
    551             } else {
    552                 Err(OperationError::UnsupportedOperation)
    553             };
    554             let _ = reply.send(result);
    555         }),
    556         Job::CaptureStockEvidence(evidence, proof, reply) => Box::pin(async move {
    557             let result = if kind == Kind::SellerStock {
    558                 Box::pin(stock::issuance::evidence::capture(
    559                     &mut stock::inventory::Turn {
    560                         connection,
    561                         namespace,
    562                         selected: input,
    563                         crypto,
    564                         clock,
    565                         uncertain,
    566                     },
    567                     *evidence,
    568                     proof,
    569                 ))
    570                 .await
    571             } else {
    572                 Err(OperationError::UnsupportedOperation)
    573             };
    574             let _ = reply.send(result);
    575         }),
    576         Job::StockEvidence(request, digest, proof, reply) => Box::pin(async move {
    577             let result = if kind == Kind::SellerStock {
    578                 Box::pin(stock::issuance::evidence::read(
    579                     &mut stock::inventory::Turn {
    580                         connection,
    581                         namespace,
    582                         selected: input,
    583                         crypto,
    584                         clock,
    585                         uncertain,
    586                     },
    587                     *request,
    588                     digest,
    589                     proof,
    590                 ))
    591                 .await
    592             } else {
    593                 Err(OperationError::UnsupportedOperation)
    594             };
    595             let _ = reply.send(result);
    596         }),
    597         Job::ClaimStockSigning(request, proof, reply) => Box::pin(async move {
    598             let result = if kind == Kind::SellerStock {
    599                 Box::pin(stock::issuance::claim::claim(
    600                     &mut stock::inventory::Turn {
    601                         connection,
    602                         namespace,
    603                         selected: input,
    604                         crypto,
    605                         clock,
    606                         uncertain,
    607                     },
    608                     *request,
    609                     proof,
    610                 ))
    611                 .await
    612             } else {
    613                 Err(OperationError::UnsupportedOperation)
    614             };
    615             let _ = reply.send(result);
    616         }),
    617         Job::AuthorizeStockExactReplay(request, proof, reply) => Box::pin(async move {
    618             let result = if kind == Kind::SellerStock {
    619                 Box::pin(stock::issuance::recovery::authorize(
    620                     &mut stock::inventory::Turn {
    621                         connection,
    622                         namespace,
    623                         selected: input,
    624                         crypto,
    625                         clock,
    626                         uncertain,
    627                     },
    628                     *request,
    629                     proof,
    630                 ))
    631                 .await
    632             } else {
    633                 Err(OperationError::UnsupportedOperation)
    634             };
    635             let _ = reply.send(result);
    636         }),
    637         Job::StockSigningAttempt(request, proof, reply) => Box::pin(async move {
    638             let result = if kind == Kind::SellerStock {
    639                 Box::pin(stock::issuance::claim::read(
    640                     &mut stock::inventory::Turn {
    641                         connection,
    642                         namespace,
    643                         selected: input,
    644                         crypto,
    645                         clock,
    646                         uncertain,
    647                     },
    648                     *request,
    649                     proof,
    650                 ))
    651                 .await
    652             } else {
    653                 Err(OperationError::UnsupportedOperation)
    654             };
    655             let _ = reply.send(result);
    656         }),
    657         Job::BindStockSigningPlan(request, proof, reply) => Box::pin(async move {
    658             let result = if kind == Kind::SellerStock {
    659                 Box::pin(stock::signing_plan::bind(
    660                     &mut stock::inventory::Turn {
    661                         connection,
    662                         namespace,
    663                         selected: input,
    664                         crypto,
    665                         clock,
    666                         uncertain,
    667                     },
    668                     *request,
    669                     proof,
    670                 ))
    671                 .await
    672             } else {
    673                 Err(OperationError::UnsupportedOperation)
    674             };
    675             let _ = reply.send(result);
    676         }),
    677         Job::StockSigningPlan(binding, minimum, operation, digest, proof, reply) => {
    678             Box::pin(async move {
    679                 let result = if kind == Kind::SellerStock {
    680                     Box::pin(stock::signing_plan::read(
    681                         &mut stock::inventory::Turn {
    682                             connection,
    683                             namespace,
    684                             selected: input,
    685                             crypto,
    686                             clock,
    687                             uncertain,
    688                         },
    689                         *binding,
    690                         minimum,
    691                         operation,
    692                         digest,
    693                         proof,
    694                     ))
    695                     .await
    696                 } else {
    697                     Err(OperationError::UnsupportedOperation)
    698                 };
    699                 let _ = reply.send(result);
    700             })
    701         }
    702         Job::PrepareStockAcceptance(request, proof, reply) => Box::pin(async move {
    703             let result = if kind == Kind::SellerStock {
    704                 Box::pin(stock::inventory::acceptance::admit(
    705                     &mut stock::inventory::Turn {
    706                         connection,
    707                         namespace,
    708                         selected: input,
    709                         crypto,
    710                         clock,
    711                         uncertain,
    712                     },
    713                     *request,
    714                     proof,
    715                 ))
    716                 .await
    717             } else {
    718                 Err(OperationError::UnsupportedOperation)
    719             };
    720             let _ = reply.send(result);
    721         }),
    722         Job::StockOrderRequest(
    723             binding,
    724             inventory_minimum,
    725             minimum,
    726             listings,
    727             selected,
    728             proof,
    729             reply,
    730         ) => Box::pin(async move {
    731             let result = if kind == Kind::SellerStock {
    732                 Box::pin(stock::source::inspect_request(
    733                     &mut stock::inventory::Turn {
    734                         connection,
    735                         namespace,
    736                         selected: input,
    737                         crypto,
    738                         clock,
    739                         uncertain,
    740                     },
    741                     *binding,
    742                     inventory_minimum,
    743                     minimum,
    744                     listings,
    745                     selected,
    746                     proof,
    747                 ))
    748                 .await
    749             } else {
    750                 Err(OperationError::UnsupportedOperation)
    751             };
    752             let _ = reply.send(result);
    753         }),
    754         Job::StockOrderHistory(
    755             binding,
    756             inventory_minimum,
    757             minimum,
    758             listings,
    759             scope,
    760             proof,
    761             reply,
    762         ) => Box::pin(async move {
    763             let result = if kind == Kind::SellerStock {
    764                 Box::pin(stock::source::query_history(
    765                     &mut stock::inventory::Turn {
    766                         connection,
    767                         namespace,
    768                         selected: input,
    769                         crypto,
    770                         clock,
    771                         uncertain,
    772                     },
    773                     *binding,
    774                     inventory_minimum,
    775                     minimum,
    776                     listings,
    777                     scope,
    778                     proof,
    779                 ))
    780                 .await
    781             } else {
    782                 Err(OperationError::UnsupportedOperation)
    783             };
    784             let _ = reply.send(result);
    785         }),
    786         Job::StockSource(binding, minimum, envelope, proof, reply) => Box::pin(async move {
    787             let result = if kind == Kind::SellerStock {
    788                 stock::source::query(
    789                     &mut stock::inventory::Turn {
    790                         connection,
    791                         namespace,
    792                         selected: input,
    793                         crypto,
    794                         clock,
    795                         uncertain,
    796                     },
    797                     *binding,
    798                     minimum,
    799                     envelope,
    800                     proof,
    801                 )
    802                 .await
    803             } else {
    804                 Err(OperationError::UnsupportedOperation)
    805             };
    806             let _ = reply.send(result);
    807         }),
    808         Job::OptionMapping(binding, minimum, key, proof, reply) => Box::pin(async move {
    809             let result = if kind == Kind::SellerStock {
    810                 stock::inventory::Turn {
    811                     connection,
    812                     namespace,
    813                     selected: input,
    814                     crypto,
    815                     clock,
    816                     uncertain,
    817                 }
    818                 .option_mapping(*binding, minimum, key, proof)
    819                 .await
    820             } else {
    821                 Err(OperationError::UnsupportedOperation)
    822             };
    823             let _ = reply.send(result);
    824         }),
    825         Job::InspectStock(binding, minimum, id, proof, reply) => Box::pin(async move {
    826             let result = if kind == Kind::SellerStock {
    827                 stock::inventory::Turn {
    828                     connection,
    829                     namespace,
    830                     selected: input,
    831                     crypto,
    832                     clock,
    833                     uncertain,
    834                 }
    835                 .inspect(*binding, minimum, id, proof)
    836                 .await
    837             } else {
    838                 Err(OperationError::UnsupportedOperation)
    839             };
    840             let _ = reply.send(result);
    841         }),
    842         Job::Pool(binding, minimum, id, proof, reply) => Box::pin(async move {
    843             let result = if kind == Kind::SellerStock {
    844                 stock::inventory::Turn {
    845                     connection,
    846                     namespace,
    847                     selected: input,
    848                     crypto,
    849                     clock,
    850                     uncertain,
    851                 }
    852                 .pool(*binding, minimum, id, proof)
    853                 .await
    854             } else {
    855                 Err(OperationError::UnsupportedOperation)
    856             };
    857             let _ = reply.send(result);
    858         }),
    859         Job::StockAuthority(selected, proof, reply) => Box::pin(async move {
    860             let result = if kind == Kind::SellerStock && !*uncertain {
    861                 stock::authenticate(
    862                     connection, namespace, input, crypto, clock, &selected, &proof,
    863                 )
    864                 .await
    865                 .map(|(receipt, _)| receipt)
    866             } else {
    867                 Err(WorkspaceError::RecoveryRequired)
    868             };
    869             if result == Err(WorkspaceError::CommitUnknown) {
    870                 *uncertain = true;
    871             }
    872             let _ = reply.send(result);
    873         }),
    874         job @ (Job::RecoverStockRewrapAdmission(..)
    875         | Job::RecoverStockEnvelope(..)
    876         | Job::RecoverStockObservation(..)
    877         | Job::RecoverCapture(..)
    878         | Job::RecoverStockEvidence(..)
    879         | Job::RecoverStockUnissued(..)) => Box::pin(async move { job.reject_recovery() }),
    880         Job::CaptureDeliveryObservation(binding, proof, observation, reply) => {
    881             Box::pin(async move {
    882                 let result = Journal {
    883                     connection,
    884                     namespace,
    885                     selected: input,
    886                     crypto,
    887                     clock,
    888                     uncertain,
    889                 }
    890                 .capture_delivery_observation(*binding, proof, *observation)
    891                 .await;
    892                 let _ = reply.send(result);
    893             })
    894         }
    895         Job::QueryDeliveryObservations(
    896             binding,
    897             operation,
    898             digest,
    899             recipient,
    900             request,
    901             proof,
    902             reply,
    903         ) => Box::pin(async move {
    904             let result = Journal {
    905                 connection,
    906                 namespace,
    907                 selected: input,
    908                 crypto,
    909                 clock,
    910                 uncertain,
    911             }
    912             .query_delivery_observations(*binding, operation, digest, recipient, request, proof)
    913             .await;
    914             let _ = reply.send(result);
    915         }),
    916         Job::PrepareDelivery(request, proof, candidate, reply) => Box::pin(async move {
    917             let result = Journal {
    918                 connection,
    919                 namespace,
    920                 selected: input,
    921                 crypto,
    922                 clock,
    923                 uncertain,
    924             }
    925             .prepare_delivery(*request, proof, candidate.map(|value| *value))
    926             .await;
    927             let _ = reply.send(result);
    928         }),
    929         Job::QueryDelivery(binding, operation, digest, recipient, request, proof, reply) => {
    930             Box::pin(async move {
    931                 let result = Journal {
    932                     connection,
    933                     namespace,
    934                     selected: input,
    935                     crypto,
    936                     clock,
    937                     uncertain,
    938                 }
    939                 .query_delivery(*binding, operation, digest, recipient, request, proof)
    940                 .await;
    941                 let _ = reply.send(result);
    942             })
    943         }
    944         Job::Install(request, proof, reply) => Box::pin(async move {
    945             let result = Journal {
    946                 connection,
    947                 namespace,
    948                 selected: input,
    949                 crypto,
    950                 clock,
    951                 uncertain,
    952             }
    953             .install_chat(*request, proof)
    954             .await;
    955             let _ = reply.send(result);
    956         }),
    957         Job::Snapshot(binding, operation, digest, proof, reply) => Box::pin(async move {
    958             let result = Journal {
    959                 connection,
    960                 namespace,
    961                 selected: input,
    962                 crypto,
    963                 clock,
    964                 uncertain,
    965             }
    966             .query_snapshot(*binding, operation, digest, proof)
    967             .await;
    968             let _ = reply.send(result);
    969         }),
    970         Job::Claim(request, proof, reply) => Box::pin(async move {
    971             let result = Journal {
    972                 connection,
    973                 namespace,
    974                 selected: input,
    975                 crypto,
    976                 clock,
    977                 uncertain,
    978             }
    979             .claim_issuance(*request, proof)
    980             .await;
    981             let _ = reply.send(result);
    982         }),
    983         Job::Attempt(request, proof, reply) => Box::pin(async move {
    984             let result = Journal {
    985                 connection,
    986                 namespace,
    987                 selected: input,
    988                 crypto,
    989                 clock,
    990                 uncertain,
    991             }
    992             .query_issuance(*request, proof)
    993             .await;
    994             let _ = reply.send(result);
    995         }),
    996         Job::Capture(selected, proof, evidence, reply) => Box::pin(async move {
    997             let result = Journal {
    998                 connection,
    999                 namespace,
   1000                 selected: input,
   1001                 crypto,
   1002                 clock,
   1003                 uncertain,
   1004             }
   1005             .capture_issuance(*selected, proof, *evidence)
   1006             .await;
   1007             let _ = reply.send(result);
   1008         }),
   1009         Job::Captured(request, proof, reply) => Box::pin(async move {
   1010             let result = Journal {
   1011                 connection,
   1012                 namespace,
   1013                 selected: input,
   1014                 crypto,
   1015                 clock,
   1016                 uncertain,
   1017             }
   1018             .query_captured(*request, proof)
   1019             .await;
   1020             let _ = reply.send(result);
   1021         }),
   1022         Job::BindPlan(binding, plan, proof, reply) => Box::pin(async move {
   1023             let result = Journal {
   1024                 connection,
   1025                 namespace,
   1026                 selected: input,
   1027                 crypto,
   1028                 clock,
   1029                 uncertain,
   1030             }
   1031             .bind_plan(*binding, plan, proof)
   1032             .await;
   1033             let _ = reply.send(result);
   1034         }),
   1035         Job::SigningPlan(binding, operation_id, digest, proof, reply) => Box::pin(async move {
   1036             let result = Journal {
   1037                 connection,
   1038                 namespace,
   1039                 selected: input,
   1040                 crypto,
   1041                 clock,
   1042                 uncertain,
   1043             }
   1044             .query_plan(*binding, operation_id, digest, proof)
   1045             .await;
   1046             let _ = reply.send(result);
   1047         }),
   1048         Job::Authenticate(selected, proof, reply) => Box::pin(async move {
   1049             let result = if *uncertain {
   1050                 Err(WorkspaceError::RecoveryRequired)
   1051             } else if kind == Kind::SellerStock {
   1052                 stock::authenticate(
   1053                     connection, namespace, input, crypto, clock, &selected, &proof,
   1054                 )
   1055                 .await
   1056                 .map(|(_, binding)| binding)
   1057             } else {
   1058                 authenticate(
   1059                     connection, namespace, input, crypto, clock, &selected, &proof,
   1060                 )
   1061                 .await
   1062                 .map(|(_, binding)| binding)
   1063             };
   1064             if result == Err(WorkspaceError::CommitUnknown) {
   1065                 *uncertain = true;
   1066             }
   1067             let _ = reply.send(result);
   1068         }),
   1069         Job::Revoke(selected, proof, reply) => Box::pin(async move {
   1070             let result = if *uncertain {
   1071                 Err(WorkspaceError::RecoveryRequired)
   1072             } else if kind == Kind::SellerStock {
   1073                 stock::revoke(
   1074                     connection, namespace, input, crypto, clock, &selected, &proof,
   1075                 )
   1076                 .await
   1077             } else {
   1078                 revoke(
   1079                     connection, namespace, input, crypto, clock, &selected, &proof,
   1080                 )
   1081                 .await
   1082             };
   1083             if result == Err(WorkspaceError::CommitUnknown) {
   1084                 *uncertain = true;
   1085             }
   1086             let _ = reply.send(result);
   1087         }),
   1088         Job::Admit(request, proof, reply) => Box::pin(async move {
   1089             let result = Journal {
   1090                 connection,
   1091                 namespace,
   1092                 selected: input,
   1093                 crypto,
   1094                 clock,
   1095                 uncertain,
   1096             }
   1097             .admit(*request, proof)
   1098             .await;
   1099             let _ = reply.send(result);
   1100         }),
   1101         Job::Operation(binding, operation_id, digest, proof, reply) => Box::pin(async move {
   1102             let result = Journal {
   1103                 connection,
   1104                 namespace,
   1105                 selected: input,
   1106                 crypto,
   1107                 clock,
   1108                 uncertain,
   1109             }
   1110             .query(*binding, operation_id, digest, proof)
   1111             .await;
   1112             let _ = reply.send(result);
   1113         }),
   1114     }
   1115 }