@ghostlytools/cli 1.11.3 → 1.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +52 -30
- package/SKILL.md +4 -2
- package/dist/assets/{api-DBlaoz8i.js → api-DLzCtePC.js} +533 -195
- package/dist/assets/api-DLzCtePC.js.map +1 -0
- package/dist/assets/{api-DgU4MZPD.js → api-DYMKyb1k.js} +2 -2
- package/dist/assets/{apiKit-DesObIDf.js → apiKit-CVaEzKWQ.js} +104 -21
- package/dist/assets/apiKit-CVaEzKWQ.js.map +1 -0
- package/dist/assets/appFetch-D56GsYuq.js +602 -0
- package/dist/assets/appFetch-D56GsYuq.js.map +1 -0
- package/dist/assets/apps-BPFW19Wc.js +1 -0
- package/dist/assets/{apps-DkMjDHML.js → apps-XnZ8VEuj.js} +66 -38
- package/dist/assets/apps-XnZ8VEuj.js.map +1 -0
- package/dist/assets/{argon2id-088uQfnH.js → argon2id-B9wFdSj6.js} +2 -3
- package/dist/assets/{argon2id-088uQfnH.js.map → argon2id-B9wFdSj6.js.map} +1 -1
- package/dist/assets/{arkade-CarKONmH.js → arkade-DryM-q5n.js} +6 -7
- package/dist/assets/arkade-DryM-q5n.js.map +1 -0
- package/dist/assets/backup-COX6j1_W.js +1 -0
- package/dist/assets/{backup-C0OJCJlM.js → backup-DpyvT9Z6.js} +108 -50
- package/dist/assets/backup-DpyvT9Z6.js.map +1 -0
- package/dist/assets/bark_ffi_wasm_bg-CcafsJla.js +5 -0
- package/dist/assets/{bark_ffi_wasm_bg-EY2uc0Bx.js.map → bark_ffi_wasm_bg-CcafsJla.js.map} +1 -1
- package/dist/assets/{bark_ffi_wasm_bg-Bxru_BVW.wasm → bark_ffi_wasm_bg-VNmaJsc9.wasm} +0 -0
- package/dist/assets/{bitcoind-CdSmvy2y.js → bitcoind-DTsrd7TF.js} +4 -5
- package/dist/assets/{bitcoind-CdSmvy2y.js.map → bitcoind-DTsrd7TF.js.map} +1 -1
- package/dist/assets/bitcoindevkit_bg-BWQHx7vd.js +5 -0
- package/dist/assets/{bitcoindevkit_bg-B-iLWrmX.js.map → bitcoindevkit_bg-BWQHx7vd.js.map} +1 -1
- package/dist/assets/bitcoindevkit_bg-DXil67yS.wasm +0 -0
- package/dist/assets/{blobFiles-BmsrvZc3.js → blobFiles-DDs34n0r.js} +4 -5
- package/dist/assets/{blobFiles-BmsrvZc3.js.map → blobFiles-DDs34n0r.js.map} +1 -1
- package/dist/assets/breez_sdk_spark_wasm_bg.wasm +0 -0
- package/dist/assets/buttons-Bq7pTXqF.js +1 -0
- package/dist/assets/{buttons-fZTEa_2i.js → buttons-BvWqHJeh.js} +46 -23
- package/dist/assets/buttons-BvWqHJeh.js.map +1 -0
- package/dist/assets/bytes-C1DNGY18.js +132 -0
- package/dist/assets/bytes-C1DNGY18.js.map +1 -0
- package/dist/assets/{childEnv-K_IzUqQx.js → childEnv-C-99hdbL.js} +2 -3
- package/dist/assets/{childEnv-K_IzUqQx.js.map → childEnv-C-99hdbL.js.map} +1 -1
- package/dist/assets/{client-Ibk3-e60.js → client-kGZ3ZdUW.js} +30 -13
- package/dist/assets/client-kGZ3ZdUW.js.map +1 -0
- package/dist/assets/{codec-DMpQqVSt.js → codec-B2rH1mfx.js} +2 -4
- package/dist/assets/{codec-DMpQqVSt.js.map → codec-B2rH1mfx.js.map} +1 -1
- package/dist/assets/domainProofs-BDNP1dIy.js +280 -0
- package/dist/assets/domainProofs-BDNP1dIy.js.map +1 -0
- package/dist/assets/{endpoint-DarqblYE.js → endpoint-B0vE5ojY.js} +421 -420
- package/dist/assets/endpoint-B0vE5ojY.js.map +1 -0
- package/dist/assets/engineErrors--9hfgKlK.js +150 -0
- package/dist/assets/engineErrors--9hfgKlK.js.map +1 -0
- package/dist/assets/{envelope-CvQVCGdf.js → envelope-Bi2kMqbp.js} +3 -4
- package/dist/assets/{envelope-CvQVCGdf.js.map → envelope-Bi2kMqbp.js.map} +1 -1
- package/dist/assets/{errors-Dt-ZnyOX.js → errors-DDLFO4Gf.js} +31 -5
- package/dist/assets/errors-DDLFO4Gf.js.map +1 -0
- package/dist/assets/{fedimintSdk-zV_5Qdqz.js → fedimintSdk-D-6H9Pe7.js} +4 -5
- package/dist/assets/{fedimintSdk-zV_5Qdqz.js.map → fedimintSdk-D-6H9Pe7.js.map} +1 -1
- package/dist/assets/fedimint_client_wasm_bg-Cr5xGD-w.js +5 -0
- package/dist/assets/{fedimint_client_wasm_bg-BtHHlFpp.js.map → fedimint_client_wasm_bg-Cr5xGD-w.js.map} +1 -1
- package/dist/assets/fileBytes-CCKbwqG_.js +1 -0
- package/dist/assets/{fileBytes-BLPZq9YU.js → fileBytes-CfvUXdSy.js} +5 -7
- package/dist/assets/fileBytes-CfvUXdSy.js.map +1 -0
- package/dist/assets/{fileBytes-B0z9A6Le.js → fileBytes-tj6-VZcB.js} +3 -4
- package/dist/assets/{fileBytes-B0z9A6Le.js.map → fileBytes-tj6-VZcB.js.map} +1 -1
- package/dist/assets/fileBytesIdb-B0zzJ6p7.js +1 -0
- package/dist/assets/{fileBytesIdb-Bmlrl9EO.js → fileBytesIdb-BJirUAjI.js} +4 -5
- package/dist/assets/{fileBytesIdb-Bmlrl9EO.js.map → fileBytesIdb-BJirUAjI.js.map} +1 -1
- package/dist/assets/{fileBytesOpfs-DBS0kbPT.js → fileBytesOpfs-DRUYLER4.js} +4 -5
- package/dist/assets/{fileBytesOpfs-DBS0kbPT.js.map → fileBytesOpfs-DRUYLER4.js.map} +1 -1
- package/dist/assets/{fixedHosts-6gKn8dp2.js → fixedHosts-CPSsGOI2.js} +4 -5
- package/dist/assets/{fixedHosts-6gKn8dp2.js.map → fixedHosts-CPSsGOI2.js.map} +1 -1
- package/dist/assets/{ghostly_iroh_web-BzAXJUYH.js → ghostly_iroh_web-DIj5xGmR.js} +2 -3
- package/dist/assets/{ghostly_iroh_web-BzAXJUYH.js.map → ghostly_iroh_web-DIj5xGmR.js.map} +1 -1
- package/dist/assets/{src-DjVj2ynY.js → groupMeta-DTQAJG50.js} +4879 -23799
- package/dist/assets/groupMeta-DTQAJG50.js.map +1 -0
- package/dist/assets/{host-CYlIiY3r.js → host-z0FAHP9Z.js} +750 -245
- package/dist/assets/host-z0FAHP9Z.js.map +1 -0
- package/dist/assets/{hyperdhtRelay-CdsLcAhY.js → hyperdhtRelay-CvsAfQRQ.js} +5 -6
- package/dist/assets/hyperdhtRelay-CvsAfQRQ.js.map +1 -0
- package/dist/assets/hyperdhtRelay-bjNGacf5.js +32 -0
- package/dist/assets/hyperdhtRelay-bjNGacf5.js.map +1 -0
- package/dist/assets/{idb-CEuoNsTv.js → idb-ewvbqyDI.js} +2 -3
- package/dist/assets/{idb-CEuoNsTv.js.map → idb-ewvbqyDI.js.map} +1 -1
- package/dist/assets/identityProofs-Cksc_K7_.js +940 -0
- package/dist/assets/identityProofs-Cksc_K7_.js.map +1 -0
- package/dist/assets/{irohWeb-D2IuloLL.js → irohWeb-CLBx5MIv.js} +3061 -86
- package/dist/assets/irohWeb-CLBx5MIv.js.map +1 -0
- package/dist/assets/joinTrace-CBr1jbch.js +1 -0
- package/dist/assets/{joinTrace-CjRDFy85.js → joinTrace-xKBe73j9.js} +2 -3
- package/dist/assets/{joinTrace-CjRDFy85.js.map → joinTrace-xKBe73j9.js.map} +1 -1
- package/dist/assets/{legacy_ciphers-JJOu0JXL.js → legacy_ciphers-BnYATjxo.js} +2 -3
- package/dist/assets/{legacy_ciphers-JJOu0JXL.js.map → legacy_ciphers-BnYATjxo.js.map} +1 -1
- package/dist/assets/linkPreview-DdMf-YAc.js +252 -0
- package/dist/assets/linkPreview-DdMf-YAc.js.map +1 -0
- package/dist/assets/{main-C0PfjKTe.js → main-CVqkvuIo.js} +536 -173
- package/dist/assets/main-CVqkvuIo.js.map +1 -0
- package/dist/assets/{mainline-Cu61qcPS.js → mainline-CVrd0C1n.js} +72 -18
- package/dist/assets/mainline-CVrd0C1n.js.map +1 -0
- package/dist/assets/mints-BcBODVVW.js +1 -0
- package/dist/assets/{mints-j5XAOk4f.js → mints-CMDLbMeH.js} +8 -6
- package/dist/assets/mints-CMDLbMeH.js.map +1 -0
- package/dist/assets/{nacl-fast-CDhNCYHs.js → nacl-fast-B1ThWvuM.js} +2 -3
- package/dist/assets/{nacl-fast-CDhNCYHs.js.map → nacl-fast-B1ThWvuM.js.map} +1 -1
- package/dist/assets/{networkReason-Dt7Yx_n4.js → networkReason-Be-hMghr.js} +10 -14
- package/dist/assets/{networkReason-Dt7Yx_n4.js.map → networkReason-Be-hMghr.js.map} +1 -1
- package/dist/assets/{noble_curves-DDWn5AH0.js → noble_curves-DqpNlhAU.js} +3 -4
- package/dist/assets/{noble_curves-DDWn5AH0.js.map → noble_curves-DqpNlhAU.js.map} +1 -1
- package/dist/assets/{noble_hashes-B7AZyFyS.js → noble_hashes-LFe1N2xt.js} +3 -4
- package/dist/assets/{noble_hashes-B7AZyFyS.js.map → noble_hashes-LFe1N2xt.js.map} +1 -1
- package/dist/assets/{nwc-CtZypDcv.js → nwc-DKE2FXr6.js} +5 -6
- package/dist/assets/{nwc-CtZypDcv.js.map → nwc-DKE2FXr6.js.map} +1 -1
- package/dist/assets/nwcProvider-pL2XqSbW.js +208 -0
- package/dist/assets/nwcProvider-pL2XqSbW.js.map +1 -0
- package/dist/assets/{openpgp-BBFr-zHQ.js → openpgp-LkR_Zof0.js} +14 -15
- package/dist/assets/{openpgp-BBFr-zHQ.js.map → openpgp-LkR_Zof0.js.map} +1 -1
- package/dist/assets/ownDid-DY3rYqDI.js +862 -0
- package/dist/assets/ownDid-DY3rYqDI.js.map +1 -0
- package/dist/assets/{ownStatus-D4HC6tNR.js → ownStatus-DMEhrpkd.js} +81 -19
- package/dist/assets/ownStatus-DMEhrpkd.js.map +1 -0
- package/dist/assets/pairedTransports-BKmvlKz1.js +581 -0
- package/dist/assets/pairedTransports-BKmvlKz1.js.map +1 -0
- package/dist/assets/paymentIntent-DySU3Ajm.js +349 -0
- package/dist/assets/paymentIntent-DySU3Ajm.js.map +1 -0
- package/dist/assets/pkarr-BQo4PcCg.js +367 -0
- package/dist/assets/pkarr-BQo4PcCg.js.map +1 -0
- package/dist/assets/{profiles-Ccdq6Xf6.js → profiles-BFSGqDFC.js} +30 -16
- package/dist/assets/profiles-BFSGqDFC.js.map +1 -0
- package/dist/assets/registry-B15Yg_1C.js +1 -0
- package/dist/assets/{registry-LvxsLJ5S.js → registry-rXgaZeNn.js} +1273 -58
- package/dist/assets/registry-rXgaZeNn.js.map +1 -0
- package/dist/assets/relay-Cjfmdec0.js +2219 -0
- package/dist/assets/relay-Cjfmdec0.js.map +1 -0
- package/dist/assets/resolve-CIc3KZMV.js +970 -0
- package/dist/assets/resolve-CIc3KZMV.js.map +1 -0
- package/dist/assets/{restoredRows-C3LcxmOw.js → restoredRows-D_WSHE7H.js} +3 -4
- package/dist/assets/{restoredRows-C3LcxmOw.js.map → restoredRows-D_WSHE7H.js.map} +1 -1
- package/dist/assets/{secretGuard-B7Hj0Kvz.js → secretGuard-B4-LlMjv.js} +75 -16
- package/dist/assets/{secretGuard-B7Hj0Kvz.js.map → secretGuard-B4-LlMjv.js.map} +1 -1
- package/dist/assets/secretGuard-BmmnEbYf.js +1 -0
- package/dist/assets/{server-Q3VcNqGt.js → server-CQR7NLCz.js} +10200 -625
- package/dist/assets/server-CQR7NLCz.js.map +1 -0
- package/dist/assets/{sha512-BYId-G-T.js → sha512-DST9fbWH.js} +2 -3
- package/dist/assets/{sha512-BYId-G-T.js.map → sha512-DST9fbWH.js.map} +1 -1
- package/dist/assets/sshForges-BnvwmNj-.js +539 -0
- package/dist/assets/sshForges-BnvwmNj-.js.map +1 -0
- package/dist/assets/{storage-Bya5b2Xt.js → storage-BpjdxvO2.js} +243 -34
- package/dist/assets/storage-BpjdxvO2.js.map +1 -0
- package/dist/assets/text-li76pThX.js +106 -0
- package/dist/assets/text-li76pThX.js.map +1 -0
- package/dist/assets/{translate-iQZq4TnY.js → translate-BcbSWkuq.js} +21 -26
- package/dist/assets/{translate-iQZq4TnY.js.map → translate-BcbSWkuq.js.map} +1 -1
- package/dist/assets/{tree-store-N362nuzZ.js → tree-store-CAchkO_l.js} +22 -6
- package/dist/assets/tree-store-CAchkO_l.js.map +1 -0
- package/dist/assets/{types-Clyb52K2.js → types-CdWwgvyt.js} +2 -3
- package/dist/assets/{types-Clyb52K2.js.map → types-CdWwgvyt.js.map} +1 -1
- package/dist/assets/{unbzip2-stream-B1C-JX9L.js → unbzip2-stream-BtkYGpC5.js} +2 -3
- package/dist/assets/{unbzip2-stream-B1C-JX9L.js.map → unbzip2-stream-BtkYGpC5.js.map} +1 -1
- package/dist/assets/{usdt-DnyTGdTX.js → usdt-CBJ4Q5Ji.js} +7 -7
- package/dist/assets/usdt-CBJ4Q5Ji.js.map +1 -0
- package/dist/assets/{waitNotice-Cn0WJ-He.js → waitNotice-BGM0QOS2.js} +27 -4
- package/dist/assets/waitNotice-BGM0QOS2.js.map +1 -0
- package/dist/assets/{web-DwgdhfcY.js → web-68CYFCl9.js} +314 -91
- package/dist/assets/web-68CYFCl9.js.map +1 -0
- package/dist/ghostly.mjs +3 -5
- package/dist/ghostly.mjs.map +1 -1
- package/npm-shrinkwrap.json +225 -200
- package/package.json +16 -16
- package/dist/assets/api-DBlaoz8i.js.map +0 -1
- package/dist/assets/apiKit-DesObIDf.js.map +0 -1
- package/dist/assets/appFetch-C8yZIq1e.js +0 -194
- package/dist/assets/appFetch-C8yZIq1e.js.map +0 -1
- package/dist/assets/apps-DkMjDHML.js.map +0 -1
- package/dist/assets/apps-rzxsjfBV.js +0 -2
- package/dist/assets/arkade-CarKONmH.js.map +0 -1
- package/dist/assets/backup-C0OJCJlM.js.map +0 -1
- package/dist/assets/backup-CgWU7x0T.js +0 -2
- package/dist/assets/bark_ffi_wasm_bg-EY2uc0Bx.js +0 -6
- package/dist/assets/bitcoindProvider-BvoRh0D5.js +0 -97
- package/dist/assets/bitcoindProvider-BvoRh0D5.js.map +0 -1
- package/dist/assets/bitcoindevkit_bg-B-iLWrmX.js +0 -6
- package/dist/assets/bitcoindevkit_bg-CRkZTSbO.wasm +0 -0
- package/dist/assets/buttons-Cco0Agfa.js +0 -2
- package/dist/assets/buttons-fZTEa_2i.js.map +0 -1
- package/dist/assets/client-Ibk3-e60.js.map +0 -1
- package/dist/assets/endpoint-DarqblYE.js.map +0 -1
- package/dist/assets/errors-Dt-ZnyOX.js.map +0 -1
- package/dist/assets/fedimint_client_wasm_bg-BtHHlFpp.js +0 -6
- package/dist/assets/fileBytes-BLPZq9YU.js.map +0 -1
- package/dist/assets/fileBytes-BtIyoDF2.js +0 -2
- package/dist/assets/fileBytesIdb-D8mAK4pF.js +0 -2
- package/dist/assets/host-CYlIiY3r.js.map +0 -1
- package/dist/assets/hyperdhtRelay-1wzya_0L.js +0 -25
- package/dist/assets/hyperdhtRelay-1wzya_0L.js.map +0 -1
- package/dist/assets/hyperdhtRelay-CdsLcAhY.js.map +0 -1
- package/dist/assets/irohWeb-D2IuloLL.js.map +0 -1
- package/dist/assets/joinTrace-D-fnt2p3.js +0 -2
- package/dist/assets/jsonOut-POtMBS_V.js +0 -16
- package/dist/assets/jsonOut-POtMBS_V.js.map +0 -1
- package/dist/assets/main-C0PfjKTe.js.map +0 -1
- package/dist/assets/mainline-Cu61qcPS.js.map +0 -1
- package/dist/assets/mints-BaOmx517.js +0 -2
- package/dist/assets/mints-j5XAOk4f.js.map +0 -1
- package/dist/assets/nwcProvider-DYHkd0iu.js +0 -88
- package/dist/assets/nwcProvider-DYHkd0iu.js.map +0 -1
- package/dist/assets/ownDid-CJ0ta8CL.js +0 -282
- package/dist/assets/ownDid-CJ0ta8CL.js.map +0 -1
- package/dist/assets/ownStatus-D4HC6tNR.js.map +0 -1
- package/dist/assets/profiles-Ccdq6Xf6.js.map +0 -1
- package/dist/assets/registry-CE0PpQAE.js +0 -2
- package/dist/assets/registry-LvxsLJ5S.js.map +0 -1
- package/dist/assets/resolve-6kVu2DE5.js +0 -400
- package/dist/assets/resolve-6kVu2DE5.js.map +0 -1
- package/dist/assets/secretGuard-DUr6bgKc.js +0 -2
- package/dist/assets/server-Q3VcNqGt.js.map +0 -1
- package/dist/assets/src-DjVj2ynY.js.map +0 -1
- package/dist/assets/sshForges-DeZ9cN9Q.js +0 -261
- package/dist/assets/sshForges-DeZ9cN9Q.js.map +0 -1
- package/dist/assets/storage-Bya5b2Xt.js.map +0 -1
- package/dist/assets/tree-store-N362nuzZ.js.map +0 -1
- package/dist/assets/usdt-DnyTGdTX.js.map +0 -1
- package/dist/assets/waitNotice-Cn0WJ-He.js.map +0 -1
- package/dist/assets/web-DwgdhfcY.js.map +0 -1
|
@@ -1,17 +1,1244 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import { a as verifiedAtprotoHandle, c as assertDomainRecord, d as chosenResolver, f as resolverById, i as resolveAtprotoHandle, l as assertNip05, p as pkarrRelays, r as resolveAtprotoDid, s as DomainCheckError, t as assertPublicServer, u as assertPublicHost } from "./resolve-
|
|
4
|
-
import { a as PUBKY_RELAYS, c as isConfigured, d as providerForIssuer, i as validForgeLogin, l as issuerFor, n as SSH_FORGE_LABEL, o as audiences, r as checkSshForge, s as clientIdFor, t as SSH_FORGE_HOST, u as oidcProviders } from "./sshForges-
|
|
1
|
+
import { a as fromZ32, d as utf8Decode, f as utf8Encode, i as fromBase64Url, l as toBase64Url, n as concatBytes, o as isZ32Key, s as randomBytes, t as bytesEqual, u as toZ32 } from "./bytes-C1DNGY18.js";
|
|
2
|
+
import { a as domainWellKnownFile, i as domainTxtRecord, l as normalizeDomain, m as wellKnownUrl, r as dnsProofName } from "./domainProofs-BDNP1dIy.js";
|
|
3
|
+
import { C as normalizeAtprotoHandle, E as verifyAtprotoRecordProof, S as isAtprotoDid, T as AtprotoProofError, _ as ATPROTO_PROOF_COLLECTION, a as verifiedAtprotoHandle, b as atprotoProofRkey, c as assertDomainRecord, d as chosenResolver, f as resolverById, g as ATPROTO_FULL_SCOPE, h as ATPROTO_DECLARED_SCOPE, i as resolveAtprotoHandle, l as assertNip05, p as pkarrRelays, r as resolveAtprotoDid, s as DomainCheckError, t as assertPublicServer, u as assertPublicHost, v as ATPROTO_PROOF_SCOPE, w as shortAtprotoDid, x as checkAtprotoProofRecord, y as atprotoProofRecord } from "./resolve-CIc3KZMV.js";
|
|
4
|
+
import { _ as sshSignCommand, a as PUBKY_RELAYS, c as isConfigured, d as providerForIssuer, g as parseSshSignature, h as parseSshPublicKey, i as validForgeLogin, l as issuerFor, m as SshSigError, n as SSH_FORGE_LABEL, o as audiences, p as SSHSIG_NAMESPACE, r as checkSshForge, s as clientIdFor, t as SSH_FORGE_HOST, u as oidcProviders, v as verifySshSignature } from "./sshForges-BnvwmNj-.js";
|
|
5
|
+
import { s as IdentityCheckUnavailable } from "./identityProofs-Cksc_K7_.js";
|
|
6
|
+
import { C as normalizePubkyKey, E as pubkyProofPath, S as newPubkyProofFolder, T as pubkyProofFile, _ as resolveDidDht, b as isPubkyKey, c as boundedIdentityFetch, f as DidDhtError, i as registeredIdentityProviders, s as reserveAdapterIds, t as ownDid, u as testBuild, w as pubkyProofCapability, x as isPubkyProofFolder, y as PUBKY_PROOF_MAX_BYTES } from "./ownDid-DY3rYqDI.js";
|
|
7
|
+
import { c as openRelayPayload, f as decodeDnsAnswers, h as readDnsName, i as RELAY_PAYLOAD_MAX_BYTES } from "./pkarr-BQo4PcCg.js";
|
|
5
8
|
import { ed25519 } from "@noble/curves/ed25519.js";
|
|
6
9
|
import { sha256 } from "@noble/hashes/sha2.js";
|
|
7
|
-
import {
|
|
10
|
+
import { base58, base64, bech32, bech32m, createBase58check } from "@scure/base";
|
|
11
|
+
import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
|
|
12
|
+
import { p256 } from "@noble/curves/nist.js";
|
|
13
|
+
import { ripemd160 } from "@noble/hashes/legacy.js";
|
|
14
|
+
import { bytesToNumberBE } from "@noble/curves/utils.js";
|
|
8
15
|
import { generateSecretKey } from "nostr-tools/pure";
|
|
9
16
|
import { decode, npubEncode } from "nostr-tools/nip19";
|
|
10
|
-
|
|
17
|
+
// ../core/src/pkdns.ts
|
|
18
|
+
/**
|
|
19
|
+
* Pubky's PKDNS records, read (https://pubky.org). A Pubky key's signed Pkarr packet names its homeserver in an
|
|
20
|
+
* HTTPS (or SVCB) record at `_pubky` whose target is the homeserver's own key; the homeserver's packet names, in
|
|
21
|
+
* HTTPS records at its root, where it answers: its Pubky TLS endpoint (target ".", for native clients) and an ICANN
|
|
22
|
+
* host name for browsers. The Pubky SDK resolves exactly this. Packets reach these functions already checked
|
|
23
|
+
* against their key (`openRelayPayload`); nothing here trusts a host or URL from anywhere else.
|
|
24
|
+
*/
|
|
25
|
+
var SVCB = 64;
|
|
26
|
+
var HTTPS = 65;
|
|
27
|
+
/** SvcParamKey "port" (RFC 9460). */
|
|
28
|
+
var PORT = 3;
|
|
29
|
+
var Z32 = /^[ybndrfg8ejkmcpqxot1uwisza345h769]{52}$/;
|
|
30
|
+
var u16 = (data, at) => data[at] << 8 | data[at + 1];
|
|
31
|
+
/** Every SVCB and HTTPS record of a DNS packet, in packet order. Throws on a malformed one. */
|
|
32
|
+
function decodeSvcbRecords(dnsPacket) {
|
|
33
|
+
const records = [];
|
|
34
|
+
for (const answer of decodeDnsAnswers(dnsPacket)) {
|
|
35
|
+
if (answer.type !== SVCB && answer.type !== HTTPS) continue;
|
|
36
|
+
const end = answer.offset + answer.length;
|
|
37
|
+
if (answer.length < 3) throw new Error("SVCB record too short");
|
|
38
|
+
const priority = u16(dnsPacket, answer.offset);
|
|
39
|
+
const { name: target, next } = readDnsName(dnsPacket, answer.offset + 2);
|
|
40
|
+
if (next > end) throw new Error("SVCB target out of bounds");
|
|
41
|
+
const params = /* @__PURE__ */ new Map();
|
|
42
|
+
for (let at = next; at < end;) {
|
|
43
|
+
if (at + 4 > end) throw new Error("SVCB parameter out of bounds");
|
|
44
|
+
const key = u16(dnsPacket, at), length = u16(dnsPacket, at + 2);
|
|
45
|
+
at += 4;
|
|
46
|
+
if (at + length > end) throw new Error("SVCB parameter out of bounds");
|
|
47
|
+
if (!params.has(key)) params.set(key, dnsPacket.slice(at, at + length));
|
|
48
|
+
at += length;
|
|
49
|
+
}
|
|
50
|
+
records.push({
|
|
51
|
+
name: answer.name.toLowerCase(),
|
|
52
|
+
priority,
|
|
53
|
+
target: target.toLowerCase(),
|
|
54
|
+
params
|
|
55
|
+
});
|
|
56
|
+
}
|
|
57
|
+
return records;
|
|
58
|
+
}
|
|
59
|
+
/**
|
|
60
|
+
* The homeserver a Pubky key's packet names: the z-base-32 key its `_pubky` record points at, or undefined. The target
|
|
61
|
+
* is read next as a key (`pubkyRecords` checks the homeserver's packet against it), so only a canonical one names a
|
|
62
|
+
* homeserver; a respelled one is none, not a lookup that fails as "no records".
|
|
63
|
+
*/
|
|
64
|
+
function pubkyHomeserverOf(dnsPacket, userZ32) {
|
|
65
|
+
const record = decodeSvcbRecords(dnsPacket).find((r) => r.name === `_pubky.${userZ32}` || r.name === "_pubky");
|
|
66
|
+
return record && isZ32Key(record.target) ? record.target : void 0;
|
|
67
|
+
}
|
|
68
|
+
/**
|
|
69
|
+
* The homeserver's web endpoint from its own packet: of the HTTPS/SVCB records at its root, the lowest priority one
|
|
70
|
+
* whose target is a public ICANN host name (not ".", not another Pkarr key, not a name that only works on private
|
|
71
|
+
* networks, which would point a contact's app inward), with its port parameter. Undefined when there is none.
|
|
72
|
+
*/
|
|
73
|
+
function homeserverWebEndpoint(dnsPacket, homeserverZ32) {
|
|
74
|
+
const records = decodeSvcbRecords(dnsPacket).filter((r) => (r.name === homeserverZ32 || r.name === "") && r.priority > 0).sort((a, b) => a.priority - b.priority);
|
|
75
|
+
for (const r of records) {
|
|
76
|
+
if (!r.target || Z32.test(r.target.split(".")[0])) continue;
|
|
77
|
+
let host;
|
|
78
|
+
try {
|
|
79
|
+
host = normalizeDomain(r.target);
|
|
80
|
+
} catch {
|
|
81
|
+
continue;
|
|
82
|
+
}
|
|
83
|
+
const port = r.params.get(PORT);
|
|
84
|
+
if (port && port.length !== 2) continue;
|
|
85
|
+
const number = port ? u16(port, 0) : void 0;
|
|
86
|
+
if (number === 0) continue;
|
|
87
|
+
return number === void 0 || number === 443 ? { host } : {
|
|
88
|
+
host,
|
|
89
|
+
port: number
|
|
90
|
+
};
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
// ../core/src/did.ts
|
|
94
|
+
/**
|
|
95
|
+
* Decentralized identifiers (W3C DID Core 1.0) as external identities, network-free half: DID syntax,
|
|
96
|
+
* the documents did:key and did:jwk carry in the identifier itself, did:web's URLs, strict parsing of a
|
|
97
|
+
* fetched DID document, and JWS / raw signatures by the keys it lists. Fetching did:web documents and
|
|
98
|
+
* did:dht records is the browser's (`packages/browser/src/proofs/did.ts`).
|
|
99
|
+
*
|
|
100
|
+
* Only keys a document lists under `authentication` or `assertionMethod` may sign for the DID: a key
|
|
101
|
+
* listed only for key agreement or capability delegation does not speak for it.
|
|
102
|
+
*/
|
|
103
|
+
var DidError = class extends Error {};
|
|
104
|
+
var DID_METHODS = [
|
|
105
|
+
"key",
|
|
106
|
+
"jwk",
|
|
107
|
+
"dht",
|
|
108
|
+
"web"
|
|
109
|
+
];
|
|
110
|
+
var RELATIONSHIPS = ["authentication", "assertionMethod"];
|
|
111
|
+
/** A fetched did.json. */
|
|
112
|
+
var DID_DOCUMENT_MAX_BYTES = 65536;
|
|
113
|
+
/** The statement file a did:web publishes beside its did.json. */
|
|
114
|
+
var DID_FILE_MAX_BYTES = 16384;
|
|
115
|
+
/** Entries read from each list of a document; the rest are ignored. */
|
|
116
|
+
var MAX_ENTRIES = 64;
|
|
117
|
+
/** The service type a did.json uses to vouch for a Ghostly proof. */
|
|
118
|
+
var DID_GHOSTLY_SERVICE = "GhostlyIdentityProof";
|
|
119
|
+
var METHOD_NAME = /^[a-z0-9]+$/;
|
|
120
|
+
var Z32_KEY = /^[ybndrfg8ejkmcpqxot1uwisza345h769]{52}$/;
|
|
121
|
+
var B64URL = /^[A-Za-z0-9_-]*$/;
|
|
122
|
+
var SEGMENT$1 = /^[A-Za-z0-9._~-]{1,64}$/;
|
|
123
|
+
var HEX64$2 = /^[a-f0-9]{64}$/;
|
|
124
|
+
var METHOD_LIST = "did:key, did:jwk, did:dht and did:web";
|
|
125
|
+
/** base64url without padding, strictly: decoding and encoding again gives the same text. */
|
|
126
|
+
function strictBase64Url(value) {
|
|
127
|
+
if (typeof value !== "string" || !B64URL.test(value) || value.length % 4 === 1) throw new DidError("Not base64url");
|
|
128
|
+
const pad = "=".repeat((4 - value.length % 4) % 4);
|
|
129
|
+
const bytes = Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/") + pad), (c) => c.charCodeAt(0));
|
|
130
|
+
if (toBase64Url(bytes) !== value) throw new DidError("Not canonical base64url");
|
|
131
|
+
return bytes;
|
|
132
|
+
}
|
|
133
|
+
var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
|
|
134
|
+
/**
|
|
135
|
+
* The DID a person typed, checked and in canonical form, or a message they can act on. Methods other than
|
|
136
|
+
* the four Ghostly checks are refused with "not supported yet"; a DID URL (a `#fragment`, `?query` or
|
|
137
|
+
* `/path`) is refused, since it names something inside a DID rather than the DID.
|
|
138
|
+
*/
|
|
139
|
+
function parseDid(input) {
|
|
140
|
+
if (typeof input !== "string") throw new DidError("Enter a DID, like did:key:z6Mk… or did:web:example.com");
|
|
141
|
+
const value = input.trim();
|
|
142
|
+
if (!/^did:/i.test(value)) throw new DidError("Enter a DID, like did:key:z6Mk… or did:web:example.com");
|
|
143
|
+
if (value.length > 512) throw new DidError(`That DID is too long (at most 512 characters)`);
|
|
144
|
+
if (/[#?/]/.test(value)) throw new DidError("Enter the DID alone, without a #fragment, ?query or /path");
|
|
145
|
+
const rest = value.slice(4);
|
|
146
|
+
const colon = rest.indexOf(":");
|
|
147
|
+
const method = colon > 0 ? rest.slice(0, colon) : "";
|
|
148
|
+
const id = colon > 0 ? rest.slice(colon + 1) : "";
|
|
149
|
+
if (!METHOD_NAME.test(method.toLowerCase()) || !id) throw new DidError("That is not a DID: it looks like did:<method>:<identifier>");
|
|
150
|
+
if (method !== method.toLowerCase() && DID_METHODS.includes(method.toLowerCase())) throw new DidError(`Write the method in lowercase: did:${method.toLowerCase()}:…`);
|
|
151
|
+
if (!DID_METHODS.includes(method)) throw new DidError(`did:${method} is not supported yet. Ghostly checks ${METHOD_LIST}.`);
|
|
152
|
+
if (!/^[\x21-\x7e]+$/.test(id)) throw new DidError("A DID has no spaces or other special characters");
|
|
153
|
+
switch (method) {
|
|
154
|
+
case "key":
|
|
155
|
+
staticKey(`did:key:${id}`);
|
|
156
|
+
return {
|
|
157
|
+
did: `did:key:${id}`,
|
|
158
|
+
method: "key",
|
|
159
|
+
id
|
|
160
|
+
};
|
|
161
|
+
case "jwk":
|
|
162
|
+
staticKey(`did:jwk:${id}`);
|
|
163
|
+
return {
|
|
164
|
+
did: `did:jwk:${id}`,
|
|
165
|
+
method: "jwk",
|
|
166
|
+
id
|
|
167
|
+
};
|
|
168
|
+
case "dht": {
|
|
169
|
+
const key = id.toLowerCase();
|
|
170
|
+
if (!Z32_KEY.test(key) || toZ32(fromZ32(key)) !== key) throw new DidError("A did:dht identifier is 52 z-base-32 characters");
|
|
171
|
+
return {
|
|
172
|
+
did: `did:dht:${key}`,
|
|
173
|
+
method: "dht",
|
|
174
|
+
id: key
|
|
175
|
+
};
|
|
176
|
+
}
|
|
177
|
+
case "web": {
|
|
178
|
+
const web = parseWeb(id);
|
|
179
|
+
return {
|
|
180
|
+
did: `did:web:${web.id}`,
|
|
181
|
+
method: "web",
|
|
182
|
+
id: web.id
|
|
183
|
+
};
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
/** The canonical form of a DID Ghostly checks (a lowercase did:web host, a lowercase did:dht key). */
|
|
188
|
+
var normalizeDid = (input) => parseDid(input).did;
|
|
189
|
+
function parseWeb(id) {
|
|
190
|
+
const [hostPart, ...path] = id.split(":");
|
|
191
|
+
const portMatch = /^(.*)%3a(\d{1,5})$/i.exec(hostPart);
|
|
192
|
+
const hostInput = portMatch ? portMatch[1] : hostPart;
|
|
193
|
+
if (/%/.test(hostInput)) throw new DidError("A did:web domain has no percent-encoding, other than %3A before a port");
|
|
194
|
+
let host;
|
|
195
|
+
try {
|
|
196
|
+
host = normalizeDomain(hostInput);
|
|
197
|
+
} catch (e) {
|
|
198
|
+
throw new DidError(`did:web: ${e.message}`);
|
|
199
|
+
}
|
|
200
|
+
if (hostInput.toLowerCase().replace(/\.$/, "") !== host) throw new DidError("did:web: write the domain as ASCII (punycode for international names)");
|
|
201
|
+
let port;
|
|
202
|
+
if (portMatch) {
|
|
203
|
+
port = Number(portMatch[2]);
|
|
204
|
+
if (!(port >= 1 && port <= 65535) || String(port) !== portMatch[2]) throw new DidError("did:web: that port is not valid");
|
|
205
|
+
}
|
|
206
|
+
if (path.length > 8) throw new DidError("did:web: at most 8 path segments");
|
|
207
|
+
for (const segment of path) if (!SEGMENT$1.test(segment) || segment === "." || segment === "..") throw new DidError("did:web: each path segment is letters, digits, dots, dashes, underscores or tildes");
|
|
208
|
+
return {
|
|
209
|
+
id: [`${host}${port ? `%3A${port}` : ""}`, ...path].join(":"),
|
|
210
|
+
host,
|
|
211
|
+
port,
|
|
212
|
+
path
|
|
213
|
+
};
|
|
214
|
+
}
|
|
215
|
+
/**
|
|
216
|
+
* A did:web (or one of its URLs) as `parseDid` writes it: the domain in lowercase, the port's `%3a` written `%3A`.
|
|
217
|
+
* A domain and percent-encoding are case-insensitive (RFC 3986), so a document may write either, and parseDid
|
|
218
|
+
* lowercased what the person typed. The path and the fragment are left as they are; one parseDid refuses too.
|
|
219
|
+
*/
|
|
220
|
+
var webForm = (value) => {
|
|
221
|
+
if (!value.startsWith("did:web:")) return value;
|
|
222
|
+
const at = value.indexOf("#");
|
|
223
|
+
const part = at < 0 ? value : value.slice(0, at);
|
|
224
|
+
let did;
|
|
225
|
+
try {
|
|
226
|
+
did = /^[\x21-\x7e]+$/.test(part) ? parseDid(part).did : part;
|
|
227
|
+
} catch {
|
|
228
|
+
did = part.replace(/%3a/g, "%3A");
|
|
229
|
+
}
|
|
230
|
+
return at < 0 ? did : did + value.slice(at);
|
|
231
|
+
};
|
|
232
|
+
var web = (did) => {
|
|
233
|
+
const parsed = parseDid(did);
|
|
234
|
+
if (parsed.method !== "web") throw new DidError("Not a did:web");
|
|
235
|
+
return parseWeb(parsed.id);
|
|
236
|
+
};
|
|
237
|
+
/** The host a did:web lives on (no port): the name looked up before contacting it. */
|
|
238
|
+
var didWebHost = (did) => web(did).host;
|
|
239
|
+
var origin = (w) => `https://${w.host}${w.port ? `:${w.port}` : ""}`;
|
|
240
|
+
/** did:web → its did.json: `/.well-known/did.json` for a bare domain, `/<path>/did.json` otherwise. */
|
|
241
|
+
function didWebDocumentUrl(did) {
|
|
242
|
+
const w = web(did);
|
|
243
|
+
return `${origin(w)}/${w.path.length ? w.path.join("/") : ".well-known"}/did.json`;
|
|
244
|
+
}
|
|
245
|
+
/** Where a did:web publishes the statement of proof `proofId`: `ghostly/<id>.json` beside its did.json. */
|
|
246
|
+
function didWebFileUrl(did, proofId) {
|
|
247
|
+
if (!HEX64$2.test(proofId)) throw new DidError("Invalid proof id");
|
|
248
|
+
const w = web(did);
|
|
249
|
+
return `${origin(w)}/${w.path.length ? w.path.join("/") : ".well-known"}/ghostly/${proofId}.json`;
|
|
250
|
+
}
|
|
251
|
+
/** The body of that file: the DID and the exact statement text. */
|
|
252
|
+
function didWebFile(did, statement) {
|
|
253
|
+
return JSON.stringify({
|
|
254
|
+
ghostly: 1,
|
|
255
|
+
did,
|
|
256
|
+
statement
|
|
257
|
+
}, null, 2) + "\n";
|
|
258
|
+
}
|
|
259
|
+
/** True when `text` is a statement file for exactly this DID and statement. */
|
|
260
|
+
function didWebFileNames(text, did, statement) {
|
|
261
|
+
if (typeof text !== "string" || utf8Encode(text).length > 16384) return false;
|
|
262
|
+
let body;
|
|
263
|
+
try {
|
|
264
|
+
body = JSON.parse(text);
|
|
265
|
+
} catch {
|
|
266
|
+
return false;
|
|
267
|
+
}
|
|
268
|
+
return isObject(body) && body.ghostly === 1 && typeof body.did === "string" && webForm(body.did) === did && body.statement === statement;
|
|
269
|
+
}
|
|
270
|
+
/** The service entry a did.json can carry instead of the file. */
|
|
271
|
+
function didGhostlyServiceEntry(did, key, proofId) {
|
|
272
|
+
return {
|
|
273
|
+
id: `${did}#ghostly-${proofId.slice(0, 12)}`,
|
|
274
|
+
type: DID_GHOSTLY_SERVICE,
|
|
275
|
+
serviceEndpoint: {
|
|
276
|
+
key,
|
|
277
|
+
proof: proofId
|
|
278
|
+
}
|
|
279
|
+
};
|
|
280
|
+
}
|
|
281
|
+
/** Multicodec prefixes (unsigned varint) of the public keys Ghostly checks, and X25519 to name it when refused. */
|
|
282
|
+
var MULTICODEC = [
|
|
283
|
+
{
|
|
284
|
+
prefix: [237, 1],
|
|
285
|
+
curve: "Ed25519",
|
|
286
|
+
length: 32
|
|
287
|
+
},
|
|
288
|
+
{
|
|
289
|
+
prefix: [231, 1],
|
|
290
|
+
curve: "secp256k1",
|
|
291
|
+
length: 33
|
|
292
|
+
},
|
|
293
|
+
{
|
|
294
|
+
prefix: [128, 36],
|
|
295
|
+
curve: "P-256",
|
|
296
|
+
length: 33
|
|
297
|
+
},
|
|
298
|
+
{
|
|
299
|
+
prefix: [236, 1],
|
|
300
|
+
curve: "X25519",
|
|
301
|
+
length: 32
|
|
302
|
+
}
|
|
303
|
+
];
|
|
304
|
+
/** A public key on its curve, validated; ECDSA keys compressed. */
|
|
305
|
+
function curveKey(curve, bytes) {
|
|
306
|
+
let smallOrder;
|
|
307
|
+
try {
|
|
308
|
+
if (curve !== "Ed25519") return (curve === "secp256k1" ? secp256k1 : p256).Point.fromBytes(bytes).toBytes(true);
|
|
309
|
+
if (bytes.length !== 32) throw new Error();
|
|
310
|
+
smallOrder = ed25519.Point.fromBytes(bytes).isSmallOrder();
|
|
311
|
+
} catch {
|
|
312
|
+
throw new DidError(`That ${curve} key is not a valid point`);
|
|
313
|
+
}
|
|
314
|
+
if (smallOrder) throw new DidError("That Ed25519 key is a point of small order, which no secret key goes with");
|
|
315
|
+
return bytes;
|
|
316
|
+
}
|
|
317
|
+
/** A `z…` multibase (base58btc) multicodec key. X25519 and unknown codecs are `undefined`. */
|
|
318
|
+
function multikey(value) {
|
|
319
|
+
if (typeof value !== "string" || !value.startsWith("z") || value.length > 128) return void 0;
|
|
320
|
+
let bytes;
|
|
321
|
+
try {
|
|
322
|
+
bytes = base58.decode(value.slice(1));
|
|
323
|
+
} catch {
|
|
324
|
+
return;
|
|
325
|
+
}
|
|
326
|
+
const codec = MULTICODEC.find((c) => bytes[0] === c.prefix[0] && bytes[1] === c.prefix[1]);
|
|
327
|
+
if (!codec || bytes.length !== codec.length + 2) return void 0;
|
|
328
|
+
if (codec.curve === "X25519") return { curve: "X25519" };
|
|
329
|
+
return {
|
|
330
|
+
curve: codec.curve,
|
|
331
|
+
publicKey: curveKey(codec.curve, bytes.subarray(2))
|
|
332
|
+
};
|
|
333
|
+
}
|
|
334
|
+
var JWK_CURVES = {
|
|
335
|
+
Ed25519: {
|
|
336
|
+
kty: "OKP",
|
|
337
|
+
curve: "Ed25519"
|
|
338
|
+
},
|
|
339
|
+
secp256k1: {
|
|
340
|
+
kty: "EC",
|
|
341
|
+
curve: "secp256k1"
|
|
342
|
+
},
|
|
343
|
+
"P-256": {
|
|
344
|
+
kty: "EC",
|
|
345
|
+
curve: "P-256"
|
|
346
|
+
}
|
|
347
|
+
};
|
|
348
|
+
/** A public JWK. Other curves are `undefined`; a malformed one throws. */
|
|
349
|
+
function jwkKey(jwk) {
|
|
350
|
+
if (!isObject(jwk)) throw new DidError("That JWK is not an object");
|
|
351
|
+
const spec = typeof jwk.crv === "string" ? JWK_CURVES[jwk.crv] : void 0;
|
|
352
|
+
if (!spec || jwk.kty !== spec.kty) return void 0;
|
|
353
|
+
const coordinate = (v) => {
|
|
354
|
+
const b = strictBase64Url(v);
|
|
355
|
+
if (b.length !== 32) throw new DidError("JWK coordinates are 32 bytes");
|
|
356
|
+
return b;
|
|
357
|
+
};
|
|
358
|
+
try {
|
|
359
|
+
if (spec.curve === "Ed25519") return {
|
|
360
|
+
curve: "Ed25519",
|
|
361
|
+
publicKey: curveKey("Ed25519", coordinate(jwk.x))
|
|
362
|
+
};
|
|
363
|
+
return {
|
|
364
|
+
curve: spec.curve,
|
|
365
|
+
publicKey: curveKey(spec.curve, concatBytes(Uint8Array.of(4), coordinate(jwk.x), coordinate(jwk.y)))
|
|
366
|
+
};
|
|
367
|
+
} catch (e) {
|
|
368
|
+
throw e instanceof DidError && /point/.test(e.message) ? e : new DidError(`That ${spec.curve} JWK is malformed`);
|
|
369
|
+
}
|
|
370
|
+
}
|
|
371
|
+
/**
|
|
372
|
+
* The single key of a did:key or did:jwk, from the identifier itself, as the method specs build their
|
|
373
|
+
* documents: did:key's `#<multibase>` and did:jwk's `#0`, both for authentication and assertionMethod
|
|
374
|
+
* (a did:jwk marked `"use": "enc"` is for encryption only).
|
|
375
|
+
*/
|
|
376
|
+
function staticKey(did) {
|
|
377
|
+
if (did.startsWith("did:key:")) {
|
|
378
|
+
const mb = did.slice(8);
|
|
379
|
+
const key = multikey(mb);
|
|
380
|
+
if (!key) throw new DidError("That did:key is not an Ed25519, secp256k1 or P-256 key Ghostly can read");
|
|
381
|
+
if (key.curve === "X25519") throw new DidError("That did:key is an X25519 encryption key: it cannot sign");
|
|
382
|
+
return {
|
|
383
|
+
id: `${did}#${mb}`,
|
|
384
|
+
curve: key.curve,
|
|
385
|
+
publicKey: key.publicKey,
|
|
386
|
+
relationships: [...RELATIONSHIPS]
|
|
387
|
+
};
|
|
388
|
+
}
|
|
389
|
+
let jwk;
|
|
390
|
+
try {
|
|
391
|
+
jwk = JSON.parse(utf8Decode(strictBase64Url(did.slice(8))));
|
|
392
|
+
} catch {
|
|
393
|
+
throw new DidError("That did:jwk does not hold a JSON Web Key");
|
|
394
|
+
}
|
|
395
|
+
if (!isObject(jwk)) throw new DidError("That did:jwk does not hold a JSON Web Key");
|
|
396
|
+
if ("d" in jwk || "p" in jwk || "k" in jwk) throw new DidError("That did:jwk contains a private key. Never share it: make a new key");
|
|
397
|
+
const key = jwkKey(jwk);
|
|
398
|
+
if (!key) throw new DidError("That did:jwk is not an Ed25519, secp256k1 or P-256 key");
|
|
399
|
+
return {
|
|
400
|
+
id: `${did}#0`,
|
|
401
|
+
curve: key.curve,
|
|
402
|
+
publicKey: key.publicKey,
|
|
403
|
+
relationships: jwk.use === "enc" ? [] : [...RELATIONSHIPS]
|
|
404
|
+
};
|
|
405
|
+
}
|
|
406
|
+
/** The document of a did:key or did:jwk, which needs no network. */
|
|
407
|
+
function staticDidDocument(did) {
|
|
408
|
+
const parsed = parseDid(did);
|
|
409
|
+
if (parsed.method !== "key" && parsed.method !== "jwk") throw new DidError(`did:${parsed.method} is resolved over the network`);
|
|
410
|
+
return {
|
|
411
|
+
did: parsed.did,
|
|
412
|
+
keys: [staticKey(parsed.did)],
|
|
413
|
+
skipped: 0,
|
|
414
|
+
services: []
|
|
415
|
+
};
|
|
416
|
+
}
|
|
417
|
+
/** An id as absolute `<did>#<fragment>`, from `#frag` or the absolute form; undefined for another DID's. */
|
|
418
|
+
function methodId(did, id) {
|
|
419
|
+
if (typeof id !== "string" || id.length > 640) return void 0;
|
|
420
|
+
const absolute = id.startsWith("#") ? `${did}${id}` : webForm(id);
|
|
421
|
+
return absolute.startsWith(`${did}#`) && absolute.length > did.length + 1 && /^[\x21-\x7e]+$/.test(absolute) ? absolute : void 0;
|
|
422
|
+
}
|
|
423
|
+
/** Key material of one verification method: `publicKeyJwk`, `publicKeyMultibase` or (Ed25519 2018) `publicKeyBase58`. */
|
|
424
|
+
function methodKey(vm) {
|
|
425
|
+
try {
|
|
426
|
+
if (vm.publicKeyJwk !== void 0) return jwkKey(vm.publicKeyJwk);
|
|
427
|
+
if (typeof vm.publicKeyMultibase === "string") {
|
|
428
|
+
const key = multikey(vm.publicKeyMultibase);
|
|
429
|
+
if (key && key.curve !== "X25519") return key;
|
|
430
|
+
if (!key && vm.type === "Ed25519VerificationKey2020" && vm.publicKeyMultibase.startsWith("z")) {
|
|
431
|
+
const raw = base58.decode(vm.publicKeyMultibase.slice(1));
|
|
432
|
+
if (raw.length === 32) return {
|
|
433
|
+
curve: "Ed25519",
|
|
434
|
+
publicKey: curveKey("Ed25519", raw)
|
|
435
|
+
};
|
|
436
|
+
}
|
|
437
|
+
return;
|
|
438
|
+
}
|
|
439
|
+
if (typeof vm.publicKeyBase58 === "string" && vm.type === "Ed25519VerificationKey2018" && vm.publicKeyBase58.length <= 64) return {
|
|
440
|
+
curve: "Ed25519",
|
|
441
|
+
publicKey: curveKey("Ed25519", base58.decode(vm.publicKeyBase58))
|
|
442
|
+
};
|
|
443
|
+
} catch {
|
|
444
|
+
return;
|
|
445
|
+
}
|
|
446
|
+
}
|
|
447
|
+
var list = (value, name) => {
|
|
448
|
+
if (value === void 0) return [];
|
|
449
|
+
if (!Array.isArray(value)) throw new DidError(`The DID document's ${name} is not a list`);
|
|
450
|
+
return value.slice(0, MAX_ENTRIES);
|
|
451
|
+
};
|
|
452
|
+
/**
|
|
453
|
+
* A fetched or resolved DID document, strictly: it must be for exactly `did`; verification methods are
|
|
454
|
+
* read from `verificationMethod` and from `authentication` / `assertionMethod` (references or embedded);
|
|
455
|
+
* `GhostlyIdentityProof` services are kept. Keys Ghostly cannot use are counted in `skipped`.
|
|
456
|
+
*/
|
|
457
|
+
function parseDidDocument(did, raw) {
|
|
458
|
+
if (!isObject(raw)) throw new DidError("The DID document is not a JSON object");
|
|
459
|
+
if (typeof raw.id !== "string" || webForm(raw.id) !== did) throw new DidError(typeof raw.id === "string" ? `The DID document is for another DID (${raw.id.slice(0, 80)})` : "The DID document has no id");
|
|
460
|
+
const keys = /* @__PURE__ */ new Map();
|
|
461
|
+
const unusable = /* @__PURE__ */ new Set();
|
|
462
|
+
let skipped = 0;
|
|
463
|
+
const add = (vm) => {
|
|
464
|
+
if (!isObject(vm)) {
|
|
465
|
+
skipped++;
|
|
466
|
+
return;
|
|
467
|
+
}
|
|
468
|
+
const id = methodId(did, vm.id);
|
|
469
|
+
if (!id) {
|
|
470
|
+
skipped++;
|
|
471
|
+
return;
|
|
472
|
+
}
|
|
473
|
+
if (keys.has(id) || unusable.has(id)) return id;
|
|
474
|
+
const key = methodKey(vm);
|
|
475
|
+
if (!key) {
|
|
476
|
+
unusable.add(id);
|
|
477
|
+
skipped++;
|
|
478
|
+
return id;
|
|
479
|
+
}
|
|
480
|
+
keys.set(id, {
|
|
481
|
+
id,
|
|
482
|
+
...key,
|
|
483
|
+
relationships: []
|
|
484
|
+
});
|
|
485
|
+
return id;
|
|
486
|
+
};
|
|
487
|
+
for (const vm of list(raw.verificationMethod, "verificationMethod")) add(vm);
|
|
488
|
+
for (const relationship of RELATIONSHIPS) for (const entry of list(raw[relationship], relationship)) {
|
|
489
|
+
const id = typeof entry === "string" ? methodId(did, entry) : add(entry);
|
|
490
|
+
const key = id ? keys.get(id) : void 0;
|
|
491
|
+
if (key && !key.relationships.includes(relationship)) key.relationships.push(relationship);
|
|
492
|
+
}
|
|
493
|
+
const services = [];
|
|
494
|
+
for (const s of list(raw.service, "service")) {
|
|
495
|
+
if (!isObject(s)) continue;
|
|
496
|
+
const types = Array.isArray(s.type) ? s.type : [s.type];
|
|
497
|
+
const endpoint = s.serviceEndpoint;
|
|
498
|
+
if (!types.includes("GhostlyIdentityProof") || !isObject(endpoint)) continue;
|
|
499
|
+
if (typeof endpoint.key === "string" && Z32_KEY.test(endpoint.key) && typeof endpoint.proof === "string" && HEX64$2.test(endpoint.proof)) services.push({
|
|
500
|
+
id: typeof s.id === "string" ? s.id.slice(0, 200) : "",
|
|
501
|
+
key: endpoint.key,
|
|
502
|
+
proof: endpoint.proof
|
|
503
|
+
});
|
|
504
|
+
}
|
|
505
|
+
return {
|
|
506
|
+
did,
|
|
507
|
+
keys: [...keys.values()].slice(0, MAX_ENTRIES),
|
|
508
|
+
skipped,
|
|
509
|
+
services: services.slice(0, 16)
|
|
510
|
+
};
|
|
511
|
+
}
|
|
512
|
+
/** Keys that may sign for the DID. */
|
|
513
|
+
var signingKeys = (doc) => doc.keys.filter((k) => k.relationships.length > 0);
|
|
514
|
+
/** JWS `alg` values Ghostly checks, and the curve each needs (RFC 8037, RFC 8812, RFC 7518, RFC 9864's Ed25519). */
|
|
515
|
+
var DID_JWS_ALGS = {
|
|
516
|
+
EdDSA: "Ed25519",
|
|
517
|
+
Ed25519: "Ed25519",
|
|
518
|
+
ES256K: "secp256k1",
|
|
519
|
+
ES256: "P-256"
|
|
520
|
+
};
|
|
521
|
+
/** The `alg` a person's tool should write for a key on this curve. */
|
|
522
|
+
var didJwsAlg = (curve) => ({
|
|
523
|
+
Ed25519: "EdDSA",
|
|
524
|
+
secp256k1: "ES256K",
|
|
525
|
+
"P-256": "ES256"
|
|
526
|
+
})[curve];
|
|
527
|
+
/** A compact JWS, attached or detached (`header..signature`), checked for shape only. */
|
|
528
|
+
function parseDidJws(input) {
|
|
529
|
+
const jws = typeof input === "string" ? input.trim() : "";
|
|
530
|
+
if (!jws || jws.length > 4096) throw new DidError("That is not a compact JWS");
|
|
531
|
+
const parts = jws.split(".");
|
|
532
|
+
if (parts.length !== 3 || !parts[0] || !parts[2]) throw new DidError("A compact JWS has three parts separated by dots");
|
|
533
|
+
let header;
|
|
534
|
+
try {
|
|
535
|
+
const bytes = strictBase64Url(parts[0]);
|
|
536
|
+
if (bytes.length > 2048) throw new Error();
|
|
537
|
+
header = JSON.parse(utf8Decode(bytes));
|
|
538
|
+
} catch {
|
|
539
|
+
throw new DidError("The JWS header is not base64url JSON");
|
|
540
|
+
}
|
|
541
|
+
if (!isObject(header)) throw new DidError("The JWS header is not a JSON object");
|
|
542
|
+
const alg = header.alg;
|
|
543
|
+
if (typeof alg !== "string" || !DID_JWS_ALGS[alg]) throw new DidError(`The JWS uses ${typeof alg === "string" ? "another algorithm" : "no algorithm"}: Ghostly checks EdDSA, ES256K and ES256`);
|
|
544
|
+
if (header.kid !== void 0 && (typeof header.kid !== "string" || header.kid.length > 640)) throw new DidError("The JWS kid is not a key id");
|
|
545
|
+
if (header.b64 !== void 0 && typeof header.b64 !== "boolean") throw new DidError("The JWS b64 header is not true or false");
|
|
546
|
+
const crit = header.crit;
|
|
547
|
+
if (crit !== void 0 && (!Array.isArray(crit) || !crit.length || crit.some((c) => c !== "b64"))) throw new DidError("The JWS requires an extension Ghostly does not know (crit)");
|
|
548
|
+
const b64 = header.b64 !== false;
|
|
549
|
+
if (!b64 && !(Array.isArray(crit) && crit.includes("b64"))) throw new DidError("A JWS with b64 false must list it in crit");
|
|
550
|
+
if (!b64 && parts[1]) throw new DidError("A JWS with b64 false must be detached (header..signature)");
|
|
551
|
+
let signature;
|
|
552
|
+
try {
|
|
553
|
+
signature = strictBase64Url(parts[2]);
|
|
554
|
+
} catch {
|
|
555
|
+
throw new DidError("The JWS signature is not base64url");
|
|
556
|
+
}
|
|
557
|
+
if (signature.length !== 64) throw new DidError(`A ${alg} signature is 64 bytes`);
|
|
558
|
+
if (parts[1]) try {
|
|
559
|
+
strictBase64Url(parts[1]);
|
|
560
|
+
} catch {
|
|
561
|
+
throw new DidError("The JWS payload is not base64url");
|
|
562
|
+
}
|
|
563
|
+
return {
|
|
564
|
+
alg,
|
|
565
|
+
curve: DID_JWS_ALGS[alg],
|
|
566
|
+
kid: header.kid,
|
|
567
|
+
b64,
|
|
568
|
+
header: parts[0],
|
|
569
|
+
payload: parts[1],
|
|
570
|
+
signature
|
|
571
|
+
};
|
|
572
|
+
}
|
|
573
|
+
/** What a JWS signs for one candidate message: its own payload when attached (which must be that message). */
|
|
574
|
+
function signingInput(jws, message) {
|
|
575
|
+
if (jws.payload) return bytesEqual(strictBase64Url(jws.payload), message) ? utf8Encode(`${jws.header}.${jws.payload}`) : void 0;
|
|
576
|
+
return jws.b64 ? utf8Encode(`${jws.header}.${toBase64Url(message)}`) : concatBytes(utf8Encode(`${jws.header}.`), message);
|
|
577
|
+
}
|
|
578
|
+
function verifyWith(key, signature, message, format = "compact") {
|
|
579
|
+
try {
|
|
580
|
+
if (key.curve === "Ed25519") return format === "compact" && ed25519.verify(signature, message, key.publicKey, { zip215: false });
|
|
581
|
+
return (key.curve === "secp256k1" ? secp256k1 : p256).verify(signature, message, key.publicKey, {
|
|
582
|
+
prehash: true,
|
|
583
|
+
lowS: false,
|
|
584
|
+
format
|
|
585
|
+
});
|
|
586
|
+
} catch {
|
|
587
|
+
return false;
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
var refusedKey = () => new DidError("Signed by a key the DID document does not list under authentication or assertionMethod");
|
|
591
|
+
/**
|
|
592
|
+
* Which key of `doc` made this JWS over one of `messages` (the statement, and the statement with a
|
|
593
|
+
* trailing newline some tools add). With a `kid`, only that key is tried. Refused unless the key is
|
|
594
|
+
* listed for authentication or assertionMethod.
|
|
595
|
+
*/
|
|
596
|
+
function checkDidJws(input, messages, doc) {
|
|
597
|
+
const jws = parseDidJws(input);
|
|
598
|
+
let candidates = doc.keys.filter((k) => k.curve === jws.curve);
|
|
599
|
+
if (jws.kid !== void 0) {
|
|
600
|
+
const kid = methodId(doc.did, jws.kid);
|
|
601
|
+
if (!kid) throw new DidError(`The JWS names a key that is not a key of ${doc.did}`);
|
|
602
|
+
candidates = candidates.filter((k) => k.id === kid);
|
|
603
|
+
if (!candidates.length) throw new DidError(doc.keys.some((k) => k.id === kid) ? `The key the JWS names is not a ${jws.curve} key: the JWS says ${jws.alg}` : "The DID document does not list the key the JWS names");
|
|
604
|
+
}
|
|
605
|
+
if (!candidates.length) throw new DidError(`The DID document lists no ${jws.curve} key for ${jws.alg}`);
|
|
606
|
+
let inputs;
|
|
607
|
+
try {
|
|
608
|
+
inputs = messages.map((m) => signingInput(jws, m)).filter((m) => !!m);
|
|
609
|
+
} catch {
|
|
610
|
+
inputs = [];
|
|
611
|
+
}
|
|
612
|
+
if (!inputs.length) throw new DidError("The JWS carries another text: sign exactly the statement shown");
|
|
613
|
+
let refused;
|
|
614
|
+
for (const key of candidates) {
|
|
615
|
+
if (!inputs.some((m) => verifyWith(key, jws.signature, m))) continue;
|
|
616
|
+
if (!key.relationships.length) {
|
|
617
|
+
refused ??= key;
|
|
618
|
+
continue;
|
|
619
|
+
}
|
|
620
|
+
return {
|
|
621
|
+
key,
|
|
622
|
+
alg: jws.alg
|
|
623
|
+
};
|
|
624
|
+
}
|
|
625
|
+
if (refused) throw refusedKey();
|
|
626
|
+
throw new DidError("The JWS signature does not match: sign exactly the statement shown, with a key of this DID");
|
|
627
|
+
}
|
|
628
|
+
/**
|
|
629
|
+
* Which key of `doc` made this raw signature over one of `messages`: Ed25519 (64 bytes), or ECDSA with
|
|
630
|
+
* SHA-256 on secp256k1 or P-256 (64 bytes r‖s, or DER as OpenSSL writes it). `vm` narrows it to one key.
|
|
631
|
+
* Returns the signature in its canonical form (r‖s for ECDSA).
|
|
632
|
+
*/
|
|
633
|
+
function checkDidSignature(signature, messages, doc, vm) {
|
|
634
|
+
let candidates = doc.keys;
|
|
635
|
+
if (vm !== void 0) {
|
|
636
|
+
const id = methodId(doc.did, vm);
|
|
637
|
+
if (!id) throw new DidError(`The proof names a key that is not a key of ${doc.did}`);
|
|
638
|
+
candidates = candidates.filter((k) => k.id === id);
|
|
639
|
+
if (!candidates.length) throw new DidError("The DID document does not list the key the proof names");
|
|
640
|
+
}
|
|
641
|
+
const der = signature.length !== 64 && signature[0] === 48;
|
|
642
|
+
if (signature.length !== 64 && !der) throw new DidError("A signature is 64 bytes (or DER, for ECDSA)");
|
|
643
|
+
let refused;
|
|
644
|
+
for (const key of candidates) {
|
|
645
|
+
if (der && key.curve === "Ed25519") continue;
|
|
646
|
+
if (!messages.some((m) => verifyWith(key, signature, m, der ? "der" : "compact"))) continue;
|
|
647
|
+
if (!key.relationships.length) {
|
|
648
|
+
refused ??= key;
|
|
649
|
+
continue;
|
|
650
|
+
}
|
|
651
|
+
const canonical = der ? (key.curve === "secp256k1" ? secp256k1 : p256).Signature.fromBytes(signature, "der").toBytes("compact") : signature;
|
|
652
|
+
return {
|
|
653
|
+
key,
|
|
654
|
+
alg: key.curve === "Ed25519" ? "Ed25519" : `ECDSA ${key.curve}`,
|
|
655
|
+
signature: canonical
|
|
656
|
+
};
|
|
657
|
+
}
|
|
658
|
+
if (refused) throw refusedKey();
|
|
659
|
+
throw new DidError("The signature does not match: sign exactly the statement shown, with a key of this DID");
|
|
660
|
+
}
|
|
661
|
+
function parseDidSignaturePaste(pasted) {
|
|
662
|
+
const tokens = (typeof pasted === "string" ? pasted : "").trim().split(/\s+/).filter(Boolean);
|
|
663
|
+
if (!tokens.length) throw new DidError("Paste the signature");
|
|
664
|
+
const vm = tokens.length > 1 && /^(did:|#)/.test(tokens[0]) ? tokens[0] : void 0;
|
|
665
|
+
const text = (vm ? tokens.slice(1) : tokens).join("");
|
|
666
|
+
if (text.split(".").length === 3) {
|
|
667
|
+
if (vm) throw new DidError("Paste the JWS alone: its header names the key (kid)");
|
|
668
|
+
return {
|
|
669
|
+
kind: "jws",
|
|
670
|
+
jws: text
|
|
671
|
+
};
|
|
672
|
+
}
|
|
673
|
+
if (text.length > 400) throw new DidError("That is too long for a signature");
|
|
674
|
+
let signature;
|
|
675
|
+
if (/^(?:[0-9a-fA-F]{2})+$/.test(text)) signature = Uint8Array.from(text.match(/../g), (h) => parseInt(h, 16));
|
|
676
|
+
else {
|
|
677
|
+
const url = text.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
|
|
678
|
+
try {
|
|
679
|
+
signature = strictBase64Url(url);
|
|
680
|
+
} catch {
|
|
681
|
+
signature = void 0;
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
if (!signature) throw new DidError("That is not a signature: paste a JWS, or a signature in hex or base64");
|
|
685
|
+
return {
|
|
686
|
+
kind: "raw",
|
|
687
|
+
vm,
|
|
688
|
+
signature
|
|
689
|
+
};
|
|
690
|
+
}
|
|
691
|
+
/** The statement bytes a signature may cover: exactly the statement, or with the newline `echo` adds. */
|
|
692
|
+
var didSignedMessages = (statement) => [utf8Encode(statement), utf8Encode(`${statement}\n`)];
|
|
693
|
+
// ../core/src/bitcoinScript.ts
|
|
694
|
+
var base58check = createBase58check(sha256);
|
|
695
|
+
var sha256d = (...parts) => sha256(sha256(concatBytes(...parts)));
|
|
696
|
+
var hash160 = (data) => ripemd160(sha256(data));
|
|
697
|
+
/** Base58 versions: P2PKH, P2SH. Every test network (testnet3/4, signet, mutinynet, regtest) shares one pair. */
|
|
698
|
+
var BASE58 = {
|
|
699
|
+
mainnet: [0, 5],
|
|
700
|
+
testnet: [111, 196]
|
|
701
|
+
};
|
|
702
|
+
var HRP = {
|
|
703
|
+
mainnet: ["bc"],
|
|
704
|
+
testnet: ["tb", "bcrt"]
|
|
705
|
+
};
|
|
706
|
+
function decodeSegwit(address) {
|
|
707
|
+
if (address !== address.toLowerCase() && address !== address.toUpperCase()) return void 0;
|
|
708
|
+
const lower = address.toLowerCase();
|
|
709
|
+
for (const [coder, v0] of [[bech32, true], [bech32m, false]]) {
|
|
710
|
+
let decoded;
|
|
711
|
+
try {
|
|
712
|
+
decoded = coder.decode(lower, 90);
|
|
713
|
+
} catch {
|
|
714
|
+
continue;
|
|
715
|
+
}
|
|
716
|
+
if (decoded.words.length < 1) return void 0;
|
|
717
|
+
const version = decoded.words[0];
|
|
718
|
+
if (version > 16 || version === 0 !== v0) return void 0;
|
|
719
|
+
let program;
|
|
720
|
+
try {
|
|
721
|
+
program = coder.fromWords(decoded.words.slice(1));
|
|
722
|
+
} catch {
|
|
723
|
+
return;
|
|
724
|
+
}
|
|
725
|
+
if (program.length < 2 || program.length > 40 || version === 0 && program.length !== 20 && program.length !== 32) return void 0;
|
|
726
|
+
return {
|
|
727
|
+
hrp: decoded.prefix,
|
|
728
|
+
version,
|
|
729
|
+
program
|
|
730
|
+
};
|
|
731
|
+
}
|
|
732
|
+
}
|
|
733
|
+
/** An address refused, with a reason fit to show the person. */
|
|
734
|
+
var BitcoinAddressError = class extends Error {};
|
|
735
|
+
/** Decodes `address` for `network`, or throws a `BitcoinAddressError` saying what is wrong with it. */
|
|
736
|
+
function decodeBitcoinAddress(address, network) {
|
|
737
|
+
if (typeof address !== "string" || address.length < 14 || address.length > 90) throw new BitcoinAddressError("Not a Bitcoin address");
|
|
738
|
+
const other = network === "mainnet" ? "testnet" : "mainnet";
|
|
739
|
+
const wrongNetwork = () => new BitcoinAddressError(network === "mainnet" ? "This is a test-network address; switch the wallets to Testnet to use it" : "This is a mainnet address; switch the wallets to Mainnet to use it");
|
|
740
|
+
const segwit = decodeSegwit(address);
|
|
741
|
+
if (segwit) {
|
|
742
|
+
if (!HRP[network].includes(segwit.hrp)) {
|
|
743
|
+
if (HRP[other].includes(segwit.hrp)) throw wrongNetwork();
|
|
744
|
+
throw new BitcoinAddressError("Not a Bitcoin address");
|
|
745
|
+
}
|
|
746
|
+
const { version, program } = segwit;
|
|
747
|
+
return {
|
|
748
|
+
address,
|
|
749
|
+
type: version === 0 ? program.length === 20 ? "p2wpkh" : "p2wsh" : version === 1 && program.length === 32 ? "p2tr" : "witness-unknown",
|
|
750
|
+
network,
|
|
751
|
+
scriptPubKey: concatBytes(Uint8Array.of(version === 0 ? 0 : 80 + version, program.length), program),
|
|
752
|
+
program,
|
|
753
|
+
witnessVersion: version
|
|
754
|
+
};
|
|
755
|
+
}
|
|
756
|
+
let payload;
|
|
757
|
+
try {
|
|
758
|
+
payload = base58check.decode(address);
|
|
759
|
+
} catch {
|
|
760
|
+
throw new BitcoinAddressError("Not a Bitcoin address (bad checksum?)");
|
|
761
|
+
}
|
|
762
|
+
if (payload.length !== 21) throw new BitcoinAddressError("Not a Bitcoin address");
|
|
763
|
+
const [pkh, sh] = BASE58[network];
|
|
764
|
+
const hash = payload.slice(1);
|
|
765
|
+
if (payload[0] === pkh) return {
|
|
766
|
+
address,
|
|
767
|
+
type: "p2pkh",
|
|
768
|
+
network,
|
|
769
|
+
program: hash,
|
|
770
|
+
scriptPubKey: concatBytes(Uint8Array.of(118, 169, 20), hash, Uint8Array.of(136, 172))
|
|
771
|
+
};
|
|
772
|
+
if (payload[0] === sh) return {
|
|
773
|
+
address,
|
|
774
|
+
type: "p2sh",
|
|
775
|
+
network,
|
|
776
|
+
program: hash,
|
|
777
|
+
scriptPubKey: concatBytes(Uint8Array.of(169, 20), hash, Uint8Array.of(135))
|
|
778
|
+
};
|
|
779
|
+
if (BASE58[other].includes(payload[0])) throw wrongNetwork();
|
|
780
|
+
throw new BitcoinAddressError("Not a Bitcoin address");
|
|
781
|
+
}
|
|
782
|
+
function compactSize(n) {
|
|
783
|
+
if (n < 253) return Uint8Array.of(n);
|
|
784
|
+
if (n <= 65535) return Uint8Array.of(253, n & 255, n >>> 8);
|
|
785
|
+
if (n <= 4294967295) {
|
|
786
|
+
const b = /* @__PURE__ */ new Uint8Array(5);
|
|
787
|
+
b[0] = 254;
|
|
788
|
+
new DataView(b.buffer).setUint32(1, n, true);
|
|
789
|
+
return b;
|
|
790
|
+
}
|
|
791
|
+
throw new Error("Too large");
|
|
792
|
+
}
|
|
793
|
+
var varBytes = (b) => concatBytes(compactSize(b.length), b);
|
|
794
|
+
var u32 = (n) => {
|
|
795
|
+
const b = /* @__PURE__ */ new Uint8Array(4);
|
|
796
|
+
new DataView(b.buffer).setUint32(0, n >>> 0, true);
|
|
797
|
+
return b;
|
|
798
|
+
};
|
|
799
|
+
var u64 = (n) => {
|
|
800
|
+
const b = /* @__PURE__ */ new Uint8Array(8);
|
|
801
|
+
new DataView(b.buffer).setBigUint64(0, n, true);
|
|
802
|
+
return b;
|
|
803
|
+
};
|
|
804
|
+
function encodeTx(tx, withWitness = tx.inputs.some((i) => i.witness.length > 0)) {
|
|
805
|
+
const parts = [u32(tx.version)];
|
|
806
|
+
if (withWitness) parts.push(Uint8Array.of(0, 1));
|
|
807
|
+
parts.push(compactSize(tx.inputs.length));
|
|
808
|
+
for (const i of tx.inputs) parts.push(i.txid, u32(i.vout), varBytes(i.scriptSig), u32(i.sequence));
|
|
809
|
+
parts.push(compactSize(tx.outputs.length));
|
|
810
|
+
for (const o of tx.outputs) parts.push(u64(o.value), varBytes(o.script));
|
|
811
|
+
if (withWitness) for (const i of tx.inputs) parts.push(encodeWitness(i.witness));
|
|
812
|
+
parts.push(u32(tx.lockTime));
|
|
813
|
+
return concatBytes(...parts);
|
|
814
|
+
}
|
|
815
|
+
var encodeWitness = (stack) => concatBytes(compactSize(stack.length), ...stack.map(varBytes));
|
|
816
|
+
/** The id other transactions refer to it by, in internal byte order (reverse it for display). */
|
|
817
|
+
var txHash = (tx) => sha256d(encodeTx(tx, false));
|
|
818
|
+
/** A strict reader: canonical sizes only, and the whole input must be consumed. */
|
|
819
|
+
var ByteReader = class {
|
|
820
|
+
bytes;
|
|
821
|
+
at = 0;
|
|
822
|
+
constructor(bytes) {
|
|
823
|
+
this.bytes = bytes;
|
|
824
|
+
}
|
|
825
|
+
get done() {
|
|
826
|
+
return this.at === this.bytes.length;
|
|
827
|
+
}
|
|
828
|
+
take(n) {
|
|
829
|
+
if (!Number.isSafeInteger(n) || n < 0 || this.at + n > this.bytes.length) throw new Error("Truncated data");
|
|
830
|
+
const out = this.bytes.slice(this.at, this.at + n);
|
|
831
|
+
this.at += n;
|
|
832
|
+
return out;
|
|
833
|
+
}
|
|
834
|
+
peek() {
|
|
835
|
+
if (this.done) throw new Error("Truncated data");
|
|
836
|
+
return this.bytes[this.at];
|
|
837
|
+
}
|
|
838
|
+
u32() {
|
|
839
|
+
return new DataView(this.take(4).buffer).getUint32(0, true);
|
|
840
|
+
}
|
|
841
|
+
i32() {
|
|
842
|
+
return new DataView(this.take(4).buffer).getInt32(0, true);
|
|
843
|
+
}
|
|
844
|
+
u64() {
|
|
845
|
+
return new DataView(this.take(8).buffer).getBigUint64(0, true);
|
|
846
|
+
}
|
|
847
|
+
compactSize() {
|
|
848
|
+
const first = this.take(1)[0];
|
|
849
|
+
const [n, min] = first < 253 ? [first, 0] : first === 253 ? [new DataView(this.take(2).buffer).getUint16(0, true), 253] : first === 254 ? [this.u32(), 65536] : [Number(this.u64()), 4294967296];
|
|
850
|
+
if (n < min || n > 33554432) throw new Error("Non-canonical size");
|
|
851
|
+
return n;
|
|
852
|
+
}
|
|
853
|
+
varBytes() {
|
|
854
|
+
return this.take(this.compactSize());
|
|
855
|
+
}
|
|
856
|
+
end() {
|
|
857
|
+
if (!this.done) throw new Error("Unexpected trailing data");
|
|
858
|
+
}
|
|
859
|
+
};
|
|
860
|
+
function decodeWitness(bytes) {
|
|
861
|
+
const r = new ByteReader(bytes);
|
|
862
|
+
const stack = readWitness(r);
|
|
863
|
+
r.end();
|
|
864
|
+
return stack;
|
|
865
|
+
}
|
|
866
|
+
function readWitness(r) {
|
|
867
|
+
const n = r.compactSize();
|
|
868
|
+
return Array.from({ length: n }, () => r.varBytes());
|
|
869
|
+
}
|
|
870
|
+
function decodeTx(bytes) {
|
|
871
|
+
const r = new ByteReader(bytes);
|
|
872
|
+
const version = r.i32();
|
|
873
|
+
let segwit = false;
|
|
874
|
+
if (r.peek() === 0) {
|
|
875
|
+
r.take(1);
|
|
876
|
+
if (r.take(1)[0] !== 1) throw new Error("Unknown transaction flag");
|
|
877
|
+
segwit = true;
|
|
878
|
+
}
|
|
879
|
+
const inputs = Array.from({ length: r.compactSize() }, () => ({
|
|
880
|
+
txid: r.take(32),
|
|
881
|
+
vout: r.u32(),
|
|
882
|
+
scriptSig: r.varBytes(),
|
|
883
|
+
sequence: r.u32(),
|
|
884
|
+
witness: []
|
|
885
|
+
}));
|
|
886
|
+
const outputs = Array.from({ length: r.compactSize() }, () => ({
|
|
887
|
+
value: r.u64(),
|
|
888
|
+
script: r.varBytes()
|
|
889
|
+
}));
|
|
890
|
+
if (segwit) {
|
|
891
|
+
for (const input of inputs) input.witness = readWitness(r);
|
|
892
|
+
if (inputs.every((i) => i.witness.length === 0)) throw new Error("Superfluous witness flag");
|
|
893
|
+
}
|
|
894
|
+
const lockTime = r.u32();
|
|
895
|
+
r.end();
|
|
896
|
+
return {
|
|
897
|
+
version,
|
|
898
|
+
inputs,
|
|
899
|
+
outputs,
|
|
900
|
+
lockTime
|
|
901
|
+
};
|
|
902
|
+
}
|
|
903
|
+
/** The address decoded on whichever network it belongs to (mainnet first), or a `BitcoinAddressError`. */
|
|
904
|
+
function decodeAnyBitcoinAddress(address) {
|
|
905
|
+
try {
|
|
906
|
+
return decodeBitcoinAddress(address, "mainnet");
|
|
907
|
+
} catch (e) {
|
|
908
|
+
if (!(e instanceof BitcoinAddressError) || !/test-network/.test(e.message)) throw e;
|
|
909
|
+
return decodeBitcoinAddress(address, "testnet");
|
|
910
|
+
}
|
|
911
|
+
}
|
|
912
|
+
// ../core/src/bip322.ts
|
|
913
|
+
/** A refusal while verifying; `inconclusive` for what cannot be checked rather than what failed. */
|
|
914
|
+
var MessageRefusal = class extends Error {
|
|
915
|
+
state;
|
|
916
|
+
constructor(state, reason) {
|
|
917
|
+
super(reason);
|
|
918
|
+
this.state = state;
|
|
919
|
+
}
|
|
920
|
+
};
|
|
921
|
+
var invalid = (reason) => new MessageRefusal("invalid", reason);
|
|
922
|
+
var inconclusive = (reason) => new MessageRefusal("inconclusive", reason);
|
|
923
|
+
var SIGHASH_DEFAULT = 0;
|
|
924
|
+
var SIGHASH_ALL = 1;
|
|
925
|
+
var OP_RETURN = Uint8Array.of(106);
|
|
926
|
+
var ZERO32 = /* @__PURE__ */ new Uint8Array(32);
|
|
927
|
+
var bip322MessageHash = (message) => schnorr.utils.taggedHash("BIP0322-signed-message", utf8Encode(message));
|
|
928
|
+
/** The virtual transaction whose only output pays the address; `to_sign` spends it. */
|
|
929
|
+
function bip322ToSpend(message, scriptPubKey) {
|
|
930
|
+
return {
|
|
931
|
+
version: 0,
|
|
932
|
+
lockTime: 0,
|
|
933
|
+
inputs: [{
|
|
934
|
+
txid: ZERO32,
|
|
935
|
+
vout: 4294967295,
|
|
936
|
+
sequence: 0,
|
|
937
|
+
witness: [],
|
|
938
|
+
scriptSig: concatBytes(Uint8Array.of(0, 32), bip322MessageHash(message))
|
|
939
|
+
}],
|
|
940
|
+
outputs: [{
|
|
941
|
+
value: 0n,
|
|
942
|
+
script: scriptPubKey
|
|
943
|
+
}]
|
|
944
|
+
};
|
|
945
|
+
}
|
|
946
|
+
/** `to_sign` with every field at the default the simple format assumes. */
|
|
947
|
+
function bip322ToSign(toSpend, witness = []) {
|
|
948
|
+
return {
|
|
949
|
+
version: 0,
|
|
950
|
+
lockTime: 0,
|
|
951
|
+
inputs: [{
|
|
952
|
+
txid: txHash(toSpend),
|
|
953
|
+
vout: 0,
|
|
954
|
+
sequence: 0,
|
|
955
|
+
scriptSig: /* @__PURE__ */ new Uint8Array(0),
|
|
956
|
+
witness
|
|
957
|
+
}],
|
|
958
|
+
outputs: [{
|
|
959
|
+
value: 0n,
|
|
960
|
+
script: OP_RETURN
|
|
961
|
+
}]
|
|
962
|
+
};
|
|
963
|
+
}
|
|
964
|
+
/** Standard base64, whitespace (a pasted line break) ignored; missing padding tolerated. */
|
|
965
|
+
function decodeBase64(text) {
|
|
966
|
+
const clean = text.replace(/\s+/g, "");
|
|
967
|
+
const padded = clean.length % 4 === 0 ? clean : clean + "=".repeat(4 - clean.length % 4);
|
|
968
|
+
try {
|
|
969
|
+
return base64.decode(padded);
|
|
970
|
+
} catch {
|
|
971
|
+
throw invalid("The signature is not valid base64");
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
/** BIP 143, for witness v0. `scriptCode` is the P2PKH script of the key. */
|
|
975
|
+
function sighashV0(tx, scriptCode, hashType) {
|
|
976
|
+
const input = tx.inputs[0];
|
|
977
|
+
return sha256d(u32(tx.version), sha256d(...tx.inputs.map((i) => concatBytes(i.txid, u32(i.vout)))), sha256d(...tx.inputs.map((i) => u32(i.sequence))), input.txid, u32(input.vout), varBytes(scriptCode), u64(0n), u32(input.sequence), sha256d(...tx.outputs.map((o) => concatBytes(u64(o.value), varBytes(o.script)))), u32(tx.lockTime), u32(hashType));
|
|
978
|
+
}
|
|
979
|
+
/** BIP 341 key path, SIGHASH_DEFAULT or SIGHASH_ALL, no annex. */
|
|
980
|
+
function sighashV1(tx, scriptPubKey, hashType) {
|
|
981
|
+
const input = tx.inputs[0];
|
|
982
|
+
return schnorr.utils.taggedHash("TapSighash", concatBytes(Uint8Array.of(0, hashType), u32(tx.version), u32(tx.lockTime), sha256(concatBytes(input.txid, u32(input.vout))), sha256(u64(0n)), sha256(varBytes(scriptPubKey)), sha256(u32(input.sequence)), sha256(concatBytes(...tx.outputs.map((o) => concatBytes(u64(o.value), varBytes(o.script))))), Uint8Array.of(0), u32(0)));
|
|
983
|
+
}
|
|
984
|
+
/** The original sighash, for P2PKH: the input's script replaced by the spent output's, the rest as is. */
|
|
985
|
+
function sighashLegacy(tx, scriptPubKey, hashType) {
|
|
986
|
+
return sha256d(encodeTx({
|
|
987
|
+
...tx,
|
|
988
|
+
inputs: tx.inputs.map((i, n) => ({
|
|
989
|
+
...i,
|
|
990
|
+
witness: [],
|
|
991
|
+
scriptSig: n === 0 ? scriptPubKey : /* @__PURE__ */ new Uint8Array(0)
|
|
992
|
+
}))
|
|
993
|
+
}, false), u32(hashType));
|
|
994
|
+
}
|
|
995
|
+
/** A check that throws on malformed input (a point off the curve…) simply does not hold. */
|
|
996
|
+
function holds$1(check) {
|
|
997
|
+
try {
|
|
998
|
+
return check();
|
|
999
|
+
} catch {
|
|
1000
|
+
return false;
|
|
1001
|
+
}
|
|
1002
|
+
}
|
|
1003
|
+
/** BIP 66 strict DER, the signature still carrying its sighash byte (Bitcoin Core's IsValidSignatureEncoding). */
|
|
1004
|
+
function isStrictDer(sig) {
|
|
1005
|
+
if (sig.length < 9 || sig.length > 73 || sig[0] !== 48 || sig[1] !== sig.length - 3 || sig[2] !== 2) return false;
|
|
1006
|
+
const lenR = sig[3];
|
|
1007
|
+
if (lenR === 0 || 5 + lenR >= sig.length) return false;
|
|
1008
|
+
const lenS = sig[5 + lenR];
|
|
1009
|
+
if (lenS === 0 || lenR + lenS + 7 !== sig.length || sig[4 + lenR] !== 2) return false;
|
|
1010
|
+
if (sig[4] & 128 || lenR > 1 && sig[4] === 0 && !(sig[5] & 128)) return false;
|
|
1011
|
+
if (sig[6 + lenR] & 128 || lenS > 1 && sig[6 + lenR] === 0 && !(sig[7 + lenR] & 128)) return false;
|
|
1012
|
+
return true;
|
|
1013
|
+
}
|
|
1014
|
+
/** An ECDSA check with BIP-322's required rules: SIGHASH_ALL, strict DER, low S, a valid public key. */
|
|
1015
|
+
function checkEcdsa(sigWithType, pubkey, sighash, compressedOnly) {
|
|
1016
|
+
if (sigWithType.length === 0) throw invalid("The signature is empty");
|
|
1017
|
+
if (!(pubkey.length === 33 ? pubkey[0] === 2 || pubkey[0] === 3 : pubkey.length === 65 && !compressedOnly && pubkey[0] === 4)) throw invalid("The signature carries a malformed public key");
|
|
1018
|
+
const hashType = sigWithType[sigWithType.length - 1];
|
|
1019
|
+
if (hashType !== SIGHASH_ALL) throw invalid("BIP-322 signatures must use SIGHASH_ALL");
|
|
1020
|
+
if (!isStrictDer(sigWithType)) throw invalid("The signature is not strictly DER-encoded");
|
|
1021
|
+
if (!holds$1(() => secp256k1.verify(sigWithType.subarray(0, -1), sighash(hashType), pubkey, {
|
|
1022
|
+
prehash: false,
|
|
1023
|
+
lowS: true,
|
|
1024
|
+
format: "der"
|
|
1025
|
+
}))) throw invalid("The signature does not match this address and message");
|
|
1026
|
+
}
|
|
1027
|
+
var P2PKH_SCRIPT = (hash) => concatBytes(Uint8Array.of(118, 169, 20), hash, Uint8Array.of(136, 172));
|
|
1028
|
+
function checkP2wpkh(tx, program) {
|
|
1029
|
+
const witness = tx.inputs[0].witness;
|
|
1030
|
+
if (witness.length !== 2) throw invalid("The signature does not match this address and message");
|
|
1031
|
+
const [sig, pubkey] = witness;
|
|
1032
|
+
if (pubkey.length !== 33 || !bytesEqual(hash160(pubkey), program)) throw invalid("The signature does not match this address and message");
|
|
1033
|
+
checkEcdsa(sig, pubkey, (t) => sighashV0(tx, P2PKH_SCRIPT(program), t), true);
|
|
1034
|
+
}
|
|
1035
|
+
/**
|
|
1036
|
+
* Whether a script-path witness commits to `outputKey` (BIP 341). When it does, a script runs that this
|
|
1037
|
+
* verifier cannot interpret; when it does not, the spend fails whatever the script says.
|
|
1038
|
+
*/
|
|
1039
|
+
function commitsToOutputKey(stack, outputKey) {
|
|
1040
|
+
const control = stack[stack.length - 1], script = stack[stack.length - 2];
|
|
1041
|
+
if (control.length < 33 || (control.length - 33) % 32 !== 0 || control.length > 4129) return false;
|
|
1042
|
+
try {
|
|
1043
|
+
const internal = schnorr.utils.lift_x(bytesToNumberBE(control.subarray(1, 33)));
|
|
1044
|
+
let node = schnorr.utils.taggedHash("TapLeaf", Uint8Array.of(control[0] & 254), varBytes(script));
|
|
1045
|
+
for (let at = 33; at < control.length; at += 32) {
|
|
1046
|
+
const sibling = control.subarray(at, at + 32);
|
|
1047
|
+
node = schnorr.utils.taggedHash("TapBranch", ...compareBytes(node, sibling) < 0 ? [node, sibling] : [sibling, node]);
|
|
1048
|
+
}
|
|
1049
|
+
const tweak = bytesToNumberBE(schnorr.utils.taggedHash("TapTweak", control.subarray(1, 33), node));
|
|
1050
|
+
if (tweak >= secp256k1.Point.Fn.ORDER) return false;
|
|
1051
|
+
const q = internal.add(secp256k1.Point.BASE.multiply(tweak)).toAffine();
|
|
1052
|
+
return q.x === bytesToNumberBE(outputKey) && Number(q.y & 1n) === (control[0] & 1);
|
|
1053
|
+
} catch {
|
|
1054
|
+
return false;
|
|
1055
|
+
}
|
|
1056
|
+
}
|
|
1057
|
+
function compareBytes(a, b) {
|
|
1058
|
+
for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return a[i] - b[i];
|
|
1059
|
+
return 0;
|
|
1060
|
+
}
|
|
1061
|
+
function checkP2tr(tx, scriptPubKey, outputKey) {
|
|
1062
|
+
const witness = tx.inputs[0].witness;
|
|
1063
|
+
if (witness.length === 0) throw invalid("The signature does not match this address and message");
|
|
1064
|
+
if (witness.length > 1) {
|
|
1065
|
+
if (witness[witness.length - 1][0] === 80) throw inconclusive("Taproot signatures with an annex cannot be checked here");
|
|
1066
|
+
if (commitsToOutputKey(witness, outputKey)) throw inconclusive("Taproot script-path signatures cannot be checked here; sign with the address's key path");
|
|
1067
|
+
throw invalid("The signature does not match this address and message");
|
|
1068
|
+
}
|
|
1069
|
+
const sig = witness[0];
|
|
1070
|
+
let hashType;
|
|
1071
|
+
if (sig.length === 64) hashType = SIGHASH_DEFAULT;
|
|
1072
|
+
else if (sig.length === 65 && sig[64] === SIGHASH_ALL) hashType = SIGHASH_ALL;
|
|
1073
|
+
else if (sig.length === 65) throw invalid("BIP-322 signatures must use SIGHASH_ALL or SIGHASH_DEFAULT");
|
|
1074
|
+
else throw invalid("The signature does not match this address and message");
|
|
1075
|
+
if (!holds$1(() => schnorr.verify(sig.subarray(0, 64), sighashV1(tx, scriptPubKey, hashType), outputKey))) throw invalid("The signature does not match this address and message");
|
|
1076
|
+
}
|
|
1077
|
+
/** Exactly two direct pushes, as P2PKH's scriptSig: `<sig> <pubkey>` (MINIMALDATA holds for these sizes). */
|
|
1078
|
+
function parseTwoPushes(script) {
|
|
1079
|
+
const items = [];
|
|
1080
|
+
for (let at = 0; at < script.length;) {
|
|
1081
|
+
const n = script[at];
|
|
1082
|
+
if (n < 1 || n > 75 || at + 1 + n > script.length) throw invalid("The signature does not match this address and message");
|
|
1083
|
+
items.push(script.subarray(at + 1, at + 1 + n));
|
|
1084
|
+
at += 1 + n;
|
|
1085
|
+
}
|
|
1086
|
+
if (items.length !== 2) throw invalid("The signature does not match this address and message");
|
|
1087
|
+
return [items[0], items[1]];
|
|
1088
|
+
}
|
|
1089
|
+
function checkInput(tx, address) {
|
|
1090
|
+
const input = tx.inputs[0];
|
|
1091
|
+
const { scriptPubKey, program } = address;
|
|
1092
|
+
switch (address.type) {
|
|
1093
|
+
case "p2wpkh":
|
|
1094
|
+
if (input.scriptSig.length) throw invalid("A native SegWit input carries no scriptSig");
|
|
1095
|
+
checkP2wpkh(tx, program);
|
|
1096
|
+
return "p2wpkh";
|
|
1097
|
+
case "p2tr":
|
|
1098
|
+
if (input.scriptSig.length) throw invalid("A native SegWit input carries no scriptSig");
|
|
1099
|
+
checkP2tr(tx, scriptPubKey, program);
|
|
1100
|
+
return "p2tr";
|
|
1101
|
+
case "p2pkh": {
|
|
1102
|
+
if (input.witness.length) throw invalid("A P2PKH input carries no witness");
|
|
1103
|
+
const [sig, pubkey] = parseTwoPushes(input.scriptSig);
|
|
1104
|
+
if (!bytesEqual(hash160(pubkey), program)) throw invalid("The signature does not match this address and message");
|
|
1105
|
+
checkEcdsa(sig, pubkey, (t) => sighashLegacy(tx, scriptPubKey, t), false);
|
|
1106
|
+
return "p2pkh";
|
|
1107
|
+
}
|
|
1108
|
+
case "p2sh": {
|
|
1109
|
+
const s = input.scriptSig;
|
|
1110
|
+
if (s.length !== 23 || s[0] !== 22 || s[1] !== 0 || s[2] !== 20) throw inconclusive("Only P2SH-wrapped single-key SegWit (P2SH-P2WPKH) can be checked here, not a multisig or other script");
|
|
1111
|
+
const redeem = s.subarray(1);
|
|
1112
|
+
if (!bytesEqual(hash160(redeem), program)) throw invalid("The signature does not match this address and message");
|
|
1113
|
+
checkP2wpkh(tx, redeem.subarray(2));
|
|
1114
|
+
return "p2sh-p2wpkh";
|
|
1115
|
+
}
|
|
1116
|
+
case "p2wsh": throw inconclusive("Script (P2WSH) addresses such as multisig cannot be checked here");
|
|
1117
|
+
default: throw inconclusive("This address type cannot be checked here");
|
|
1118
|
+
}
|
|
1119
|
+
}
|
|
1120
|
+
/** Checks a BIP-322 signature — `smp…`, `ful…`, or an unprefixed one read as simple — or throws a `MessageRefusal`. */
|
|
1121
|
+
function verifyBip322(address, message, signature) {
|
|
1122
|
+
const text = signature.trim();
|
|
1123
|
+
if (text.startsWith("pof")) throw inconclusive("Proof-of-funds signatures are not accepted: Ghostly does not check balances or coins");
|
|
1124
|
+
const format = text.startsWith("ful") ? "bip322-full" : "bip322-simple";
|
|
1125
|
+
const bytes = decodeBase64(text.startsWith("smp") || text.startsWith("ful") ? text.slice(3) : text);
|
|
1126
|
+
if (bytes.length === 0) throw invalid("The signature is empty");
|
|
1127
|
+
const toSpend = bip322ToSpend(message, address.scriptPubKey);
|
|
1128
|
+
let toSign;
|
|
1129
|
+
if (format === "bip322-simple") {
|
|
1130
|
+
if (address.type === "p2pkh" || address.type === "p2sh") throw invalid("A simple BIP-322 signature is only for native SegWit addresses; this one needs the full format (ful…)");
|
|
1131
|
+
let witness;
|
|
1132
|
+
try {
|
|
1133
|
+
witness = decodeWitness(bytes);
|
|
1134
|
+
} catch {
|
|
1135
|
+
throw invalid("The signature is not a BIP-322 witness");
|
|
1136
|
+
}
|
|
1137
|
+
toSign = bip322ToSign(toSpend, witness);
|
|
1138
|
+
} else {
|
|
1139
|
+
try {
|
|
1140
|
+
toSign = decodeTx(bytes);
|
|
1141
|
+
} catch {
|
|
1142
|
+
throw invalid("The signature is not a BIP-322 full transaction");
|
|
1143
|
+
}
|
|
1144
|
+
if (toSign.inputs.length !== 1) throw inconclusive("Signatures over extra coins (proof of funds) are not accepted");
|
|
1145
|
+
const [input] = toSign.inputs;
|
|
1146
|
+
if (!bytesEqual(input.txid, txHash(toSpend)) || input.vout !== 0) throw invalid("The signature does not match this address and message");
|
|
1147
|
+
if (toSign.outputs.length !== 1 || toSign.outputs[0].value !== 0n || !bytesEqual(toSign.outputs[0].script, OP_RETURN)) throw invalid("The signature is not a BIP-322 transaction");
|
|
1148
|
+
if (toSign.version !== 0 && toSign.version !== 2) throw inconclusive("Unknown BIP-322 transaction version");
|
|
1149
|
+
}
|
|
1150
|
+
const script = checkInput(toSign, address);
|
|
1151
|
+
const { lockTime } = toSign, { sequence } = toSign.inputs[0];
|
|
1152
|
+
return lockTime || sequence ? {
|
|
1153
|
+
format,
|
|
1154
|
+
script,
|
|
1155
|
+
lockTime,
|
|
1156
|
+
sequence
|
|
1157
|
+
} : {
|
|
1158
|
+
format,
|
|
1159
|
+
script
|
|
1160
|
+
};
|
|
1161
|
+
}
|
|
1162
|
+
// ../core/src/bitcoinMessage.ts
|
|
1163
|
+
/**
|
|
1164
|
+
* Verifies a signed message for a Bitcoin address, in either format wallets produce:
|
|
1165
|
+
*
|
|
1166
|
+
* - **BIP-322** (see bip322.ts): `smp…` / `ful…`, or unprefixed from wallets that predate the prefixes.
|
|
1167
|
+
* - **Legacy signmessage** (Bitcoin Core `signmessage`, Electrum, most hardware wallets): a 65-byte
|
|
1168
|
+
* recoverable ECDSA signature. BIP-322 restricts it to **P2PKH** addresses (1…, m…, n…), and so does
|
|
1169
|
+
* this verifier: for SegWit addresses the legacy format does not commit to the script, and wallets
|
|
1170
|
+
* disagree on its header bytes (BIP 137 vs Electrum).
|
|
1171
|
+
*
|
|
1172
|
+
* A valid result proves the signer could sign for the address when they signed. It does not prove a
|
|
1173
|
+
* balance, a past payment, or that they would spend from it.
|
|
1174
|
+
*/
|
|
1175
|
+
var MAX_MESSAGE = 16384;
|
|
1176
|
+
var MAX_SIGNATURE$1 = 16384;
|
|
1177
|
+
var MAGIC = utf8Encode("Bitcoin Signed Message:\n");
|
|
1178
|
+
/** The digest `signmessage` signs: double SHA-256 of the length-prefixed magic and message. */
|
|
1179
|
+
function legacyMessageHash(message) {
|
|
1180
|
+
const bytes = utf8Encode(message);
|
|
1181
|
+
return sha256d(compactSize(MAGIC.length), MAGIC, compactSize(bytes.length), bytes);
|
|
1182
|
+
}
|
|
1183
|
+
/** Header bytes 27-34 are P2PKH (uncompressed 27-30, compressed 31-34); 35-42 are BIP 137 SegWit headers. */
|
|
1184
|
+
var isLegacySignature = (bytes) => bytes.length === 65 && bytes[0] >= 27 && bytes[0] <= 42;
|
|
1185
|
+
function verifyLegacy(address, message, bytes) {
|
|
1186
|
+
if (address.type !== "p2pkh") throw new MessageRefusal("invalid", "This is a legacy (signmessage) signature, which Ghostly accepts only for legacy 1…/m…/n… addresses. Sign with BIP-322 for this address.");
|
|
1187
|
+
const header = bytes[0];
|
|
1188
|
+
if (header > 34) throw new MessageRefusal("invalid", "This legacy signature is marked for a SegWit address, not this one");
|
|
1189
|
+
const compressed = header >= 31;
|
|
1190
|
+
const recovery = header - 27 & 3;
|
|
1191
|
+
let pubkey;
|
|
1192
|
+
try {
|
|
1193
|
+
pubkey = secp256k1.Signature.fromBytes(concatBytes(Uint8Array.of(recovery), bytes.subarray(1)), "recovered").recoverPublicKey(legacyMessageHash(message)).toBytes(compressed);
|
|
1194
|
+
} catch {
|
|
1195
|
+
throw new MessageRefusal("invalid", "The signature does not match this address and message");
|
|
1196
|
+
}
|
|
1197
|
+
if (!bytesEqual(hash160(pubkey), address.program)) throw new MessageRefusal("invalid", "The signature does not match this address and message");
|
|
1198
|
+
}
|
|
1199
|
+
/** Never throws: every refusal comes back as `invalid` or `inconclusive` with a reason fit to show. */
|
|
1200
|
+
function verifyBitcoinMessage({ address, message, signature, network }) {
|
|
1201
|
+
try {
|
|
1202
|
+
if (typeof message !== "string" || typeof signature !== "string" || typeof address !== "string") throw new MessageRefusal("invalid", "Missing address, message or signature");
|
|
1203
|
+
if (utf8Encode(message).length > MAX_MESSAGE) throw new MessageRefusal("invalid", "The message is too long");
|
|
1204
|
+
const text = signature.trim();
|
|
1205
|
+
if (!text) throw new MessageRefusal("invalid", "The signature is empty");
|
|
1206
|
+
if (text.length > MAX_SIGNATURE$1) throw new MessageRefusal("invalid", "The signature is too long");
|
|
1207
|
+
const decoded = decodeBitcoinAddress(address.trim(), network);
|
|
1208
|
+
if (!/^(smp|ful|pof)/.test(text)) {
|
|
1209
|
+
const bytes = decodeBase64(text);
|
|
1210
|
+
if (isLegacySignature(bytes)) {
|
|
1211
|
+
verifyLegacy(decoded, message, bytes);
|
|
1212
|
+
return {
|
|
1213
|
+
state: "valid",
|
|
1214
|
+
format: "legacy",
|
|
1215
|
+
script: "p2pkh"
|
|
1216
|
+
};
|
|
1217
|
+
}
|
|
1218
|
+
}
|
|
1219
|
+
return {
|
|
1220
|
+
state: "valid",
|
|
1221
|
+
...verifyBip322(decoded, message, text)
|
|
1222
|
+
};
|
|
1223
|
+
} catch (e) {
|
|
1224
|
+
if (e instanceof MessageRefusal) return {
|
|
1225
|
+
state: e.state,
|
|
1226
|
+
reason: e.message
|
|
1227
|
+
};
|
|
1228
|
+
if (e instanceof BitcoinAddressError) return {
|
|
1229
|
+
state: "invalid",
|
|
1230
|
+
reason: e.message
|
|
1231
|
+
};
|
|
1232
|
+
return {
|
|
1233
|
+
state: "invalid",
|
|
1234
|
+
reason: "The signature could not be read"
|
|
1235
|
+
};
|
|
1236
|
+
}
|
|
1237
|
+
}
|
|
1238
|
+
// ../browser/src/proofs/contract.ts
|
|
11
1239
|
/** `english` with its `{{name}}`s filled in: what `ProviderSay` returns where no app language is at hand (the CLI, tests). */
|
|
12
1240
|
var englishSay = (_key, english, values) => values ? english.replace(/\{\{(\w+)\}\}/g, (all, name) => name in values ? String(values[name]) : all) : english;
|
|
13
|
-
|
|
14
|
-
//#region ../browser/src/proofs/bitcoinWallets.ts
|
|
1241
|
+
// ../browser/src/proofs/bitcoinWallets.ts
|
|
15
1242
|
/** What a proof proves and what it does not; shown next to every Bitcoin proof, given or received. */
|
|
16
1243
|
var BITCOIN_PROOF_LIMITS = [
|
|
17
1244
|
"Proves: whoever made this signature could sign with the key behind this address when they signed.",
|
|
@@ -116,8 +1343,7 @@ var BITCOIN_WALLET_GUIDES = [
|
|
|
116
1343
|
function guidesFor(script) {
|
|
117
1344
|
return BITCOIN_WALLET_GUIDES.filter((g) => g.scripts.includes(script));
|
|
118
1345
|
}
|
|
119
|
-
|
|
120
|
-
//#region ../browser/src/proofs/providers/bitcoin.ts
|
|
1346
|
+
// ../browser/src/proofs/providers/bitcoin.ts
|
|
121
1347
|
var MAX_SIGNATURE = 8192;
|
|
122
1348
|
var SIGNATURE = /^(smp|ful|pof)?[A-Za-z0-9+/]+={0,2}$/;
|
|
123
1349
|
/** Each address type's name, said under `scripts.<type>` (exported for the app's drift guard). */
|
|
@@ -277,8 +1503,7 @@ var bitcoin = {
|
|
|
277
1503
|
};
|
|
278
1504
|
}
|
|
279
1505
|
};
|
|
280
|
-
|
|
281
|
-
//#region ../browser/src/proofs/displaySource.ts
|
|
1506
|
+
// ../browser/src/proofs/displaySource.ts
|
|
282
1507
|
/**
|
|
283
1508
|
* Where a proof's name came from (`display.source`), and how a Nostr proof was checked (`verified.source`), in the
|
|
284
1509
|
* fixed words the providers write them in. The app says these
|
|
@@ -298,8 +1523,7 @@ var NOSTR_SIGNATURE_SOURCE = "Nostr signature (NIP-01, BIP-340)";
|
|
|
298
1523
|
function oidcDisplaySource(provider, email, nameUnchecked = false) {
|
|
299
1524
|
return `Signed by ${provider}${email === "verified" ? `; email verified by ${provider}` : email === "unverified" ? `; email not verified by ${provider}` : ""}${nameUnchecked ? `; name set on the account, not checked by ${provider}` : ""}`;
|
|
300
1525
|
}
|
|
301
|
-
|
|
302
|
-
//#region ../browser/src/proofs/nostr.ts
|
|
1526
|
+
// ../browser/src/proofs/nostr.ts
|
|
303
1527
|
function extensionSigner() {
|
|
304
1528
|
return globalThis.nostr;
|
|
305
1529
|
}
|
|
@@ -378,6 +1602,7 @@ async function withNostrSigner(options, work) {
|
|
|
378
1602
|
signer = BunkerSigner.fromBunker(clientKey, bp, {
|
|
379
1603
|
pool,
|
|
380
1604
|
skipSwitchRelays: true,
|
|
1605
|
+
timeout: 0,
|
|
381
1606
|
onauth: (url) => {
|
|
382
1607
|
try {
|
|
383
1608
|
const u = new URL(url);
|
|
@@ -409,8 +1634,7 @@ async function withNostrSigner(options, work) {
|
|
|
409
1634
|
clientKey?.fill(0);
|
|
410
1635
|
}
|
|
411
1636
|
}
|
|
412
|
-
|
|
413
|
-
//#region ../browser/src/proofs/providers/nostr.ts
|
|
1637
|
+
// ../browser/src/proofs/providers/nostr.ts
|
|
414
1638
|
/**
|
|
415
1639
|
* NIP-78 application data (kind 30078): no new kind is claimed. Signers show it as such; it is never
|
|
416
1640
|
* published to a relay — the event travels only to the contacts the person shares it with.
|
|
@@ -427,7 +1651,7 @@ function nostrProofTemplate(statement) {
|
|
|
427
1651
|
tags: [["d", "ghostly-identity-proof"], ["expiration", String(expiresAt)]]
|
|
428
1652
|
};
|
|
429
1653
|
}
|
|
430
|
-
var hex$
|
|
1654
|
+
var hex$2 = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
|
|
431
1655
|
var unhex$1 = (s) => Uint8Array.from(s.match(/../g), (x) => parseInt(x, 16));
|
|
432
1656
|
function normalizeNostrKey(input) {
|
|
433
1657
|
const value = input.trim();
|
|
@@ -511,7 +1735,7 @@ var nostr = {
|
|
|
511
1735
|
const expected = nostrProofTemplate(statement);
|
|
512
1736
|
if (event.pubkey !== statement.binding.subject) throw new Error("Signed by another Nostr key");
|
|
513
1737
|
if (event.kind !== expected.kind || event.created_at !== expected.created_at || event.content !== expected.content || JSON.stringify(event.tags) !== JSON.stringify(expected.tags)) throw new Error("The signer did not sign the exact Ghostly statement");
|
|
514
|
-
const id = hex$
|
|
1738
|
+
const id = hex$2(sha256(utf8Encode(JSON.stringify([
|
|
515
1739
|
0,
|
|
516
1740
|
event.pubkey,
|
|
517
1741
|
event.created_at,
|
|
@@ -533,8 +1757,7 @@ var nostr = {
|
|
|
533
1757
|
};
|
|
534
1758
|
}
|
|
535
1759
|
};
|
|
536
|
-
|
|
537
|
-
//#region ../browser/src/proofs/providers/domain.ts
|
|
1760
|
+
// ../browser/src/proofs/providers/domain.ts
|
|
538
1761
|
/**
|
|
539
1762
|
* A long domain as a card shows it: its end, the part that names who owns it (`…ghostly.tools`), never its start, which
|
|
540
1763
|
* is whatever the owner chose (`github.com.account-…` under any domain they own). Whole labels from the end, as many as
|
|
@@ -717,8 +1940,7 @@ var domain = {
|
|
|
717
1940
|
};
|
|
718
1941
|
}
|
|
719
1942
|
};
|
|
720
|
-
|
|
721
|
-
//#region ../browser/src/proofs/openpgp.ts
|
|
1943
|
+
// ../browser/src/proofs/openpgp.ts
|
|
722
1944
|
/**
|
|
723
1945
|
* OpenPGP identity proofs (RFC 9580, and the RFC 4880 v4 keys people actually have).
|
|
724
1946
|
*
|
|
@@ -767,7 +1989,7 @@ var PGP_LIMITS = {
|
|
|
767
1989
|
var loading;
|
|
768
1990
|
/** The only place OpenPGP.js is imported: a separate chunk, fetched on first use. */
|
|
769
1991
|
function loadOpenPgp() {
|
|
770
|
-
loading ??= import("./openpgp-
|
|
1992
|
+
loading ??= import("./openpgp-LkR_Zof0.js").then((m) => m).catch((e) => {
|
|
771
1993
|
loading = void 0;
|
|
772
1994
|
throw e;
|
|
773
1995
|
});
|
|
@@ -845,9 +2067,9 @@ var PGP_NO_USER_IDS = "This copy of the key has no user IDs (keys.openpgp.org le
|
|
|
845
2067
|
/** Armored blocks in pasted text; more BEGIN lines than any real paste has are refused before the regex scans. */
|
|
846
2068
|
function armorBlocks(text) {
|
|
847
2069
|
if ((text.match(/-----BEGIN PGP /g) ?? []).length > 4) throw new PgpProofError("Paste only what gpg printed: one signature and your public key.");
|
|
848
|
-
return [...text.matchAll(ARMOR)];
|
|
2070
|
+
return [...text.matchAll(ARMOR$1)];
|
|
849
2071
|
}
|
|
850
|
-
var ARMOR = /-----BEGIN PGP SIGNED MESSAGE-----[\s\S]*?-----END PGP SIGNATURE-----|-----BEGIN PGP ([A-Z ,/0-9]+)-----[\s\S]*?-----END PGP \1-----/g;
|
|
2072
|
+
var ARMOR$1 = /-----BEGIN PGP SIGNED MESSAGE-----[\s\S]*?-----END PGP SIGNATURE-----|-----BEGIN PGP ([A-Z ,/0-9]+)-----[\s\S]*?-----END PGP \1-----/g;
|
|
851
2073
|
/** The single armored block in pasted text (terminal output may surround it). */
|
|
852
2074
|
function armoredBlock(text, what) {
|
|
853
2075
|
if (/PRIVATE KEY BLOCK/.test(text)) throw new PgpProofError("This is a PRIVATE key. Never paste it anywhere: Ghostly only needs your public key (gpg --armor --export).");
|
|
@@ -1318,8 +2540,7 @@ async function keyserverVerifiedEmails(keyserverArmored, fingerprint, options =
|
|
|
1318
2540
|
const emails = info.userIds.map((u) => /<([^<>\s]+@[^<>\s]+)>\s*$/.exec(u)?.[1] ?? (/^[^<>\s]+@[^<>\s]+$/.test(u) ? u : void 0));
|
|
1319
2541
|
return [...new Set(emails.filter((e) => !!e).map((e) => e.toLowerCase()))];
|
|
1320
2542
|
}
|
|
1321
|
-
|
|
1322
|
-
//#region ../browser/src/proofs/providers/openpgp.ts
|
|
2543
|
+
// ../browser/src/proofs/providers/openpgp.ts
|
|
1323
2544
|
/**
|
|
1324
2545
|
* OpenPGP keys, signed with the person's own gpg — a YubiKey or another OpenPGP card works unchanged,
|
|
1325
2546
|
* since gpg drives it. The subject is the primary key's fingerprint. See docs/wisps/305-openpgp.md.
|
|
@@ -1456,8 +2677,7 @@ var openpgp = {
|
|
|
1456
2677
|
};
|
|
1457
2678
|
}
|
|
1458
2679
|
};
|
|
1459
|
-
|
|
1460
|
-
//#region ../browser/src/proofs/providers/ssh.ts
|
|
2680
|
+
// ../browser/src/proofs/providers/ssh.ts
|
|
1461
2681
|
var FINGERPRINT = /^SHA256:[A-Za-z0-9+/]{43}$/;
|
|
1462
2682
|
/** The line `ssh-keygen -l -f key.pub` prints: bits, fingerprint, comment, type ("256 SHA256:… me@laptop (ED25519)"). */
|
|
1463
2683
|
var KEYGEN_LIST_LINE = /^\d+ (SHA256:[A-Za-z0-9+/]{43}) .* \([A-Z0-9-]+\)$/;
|
|
@@ -1478,11 +2698,18 @@ function normalizeLogin(forge, input) {
|
|
|
1478
2698
|
if (!validForgeLogin(forge, login)) throw new Error(`Enter a ${SSH_FORGE_LABEL[forge]} username`);
|
|
1479
2699
|
return login;
|
|
1480
2700
|
}
|
|
2701
|
+
/**
|
|
2702
|
+
* The armored block, without what the terminal showed around it (ssh-keygen's "Signing data on standard input", a prompt);
|
|
2703
|
+
* the last one when the command ran more than once there (Add started over, a run without -n ghostly).
|
|
2704
|
+
*/
|
|
2705
|
+
var ARMOR = /-----BEGIN SSH SIGNATURE-----[\s\S]*?-----END SSH SIGNATURE-----/g;
|
|
2706
|
+
var armorIn = (pasted) => pasted.length > 24576 ? pasted : pasted.match(ARMOR)?.pop() ?? pasted;
|
|
1481
2707
|
/** The armor, re-wrapped canonically, so evidence is the same whatever the clipboard did to it. */
|
|
1482
2708
|
function canonicalArmor(pasted) {
|
|
1483
|
-
const
|
|
2709
|
+
const armor = armorIn(pasted);
|
|
2710
|
+
const parsed = parseSshSignature(armor);
|
|
1484
2711
|
if (parsed.namespace !== "ghostly") throw new Error(`That signature is for "${parsed.namespace}", not "${SSHSIG_NAMESPACE}": run the command with -n ${SSHSIG_NAMESPACE}`);
|
|
1485
|
-
return `-----BEGIN SSH SIGNATURE-----\n${
|
|
2712
|
+
return `-----BEGIN SSH SIGNATURE-----\n${armor.replace(/\r\n/g, "\n").trim().split("\n").map((l) => l.trim()).slice(1, -1).join("").match(/.{1,70}/g).join("\n")}\n-----END SSH SIGNATURE-----\n`;
|
|
1486
2713
|
}
|
|
1487
2714
|
/** Exactly the statement; or with one trailing newline ("\r\n" on Windows), which an editor adds when the
|
|
1488
2715
|
* statement is saved to a file and signed there (the Windows route). Nothing else is accepted. */
|
|
@@ -1631,15 +2858,13 @@ function forgeProvider(forge) {
|
|
|
1631
2858
|
}
|
|
1632
2859
|
var sshGithub = forgeProvider("github");
|
|
1633
2860
|
var sshGitlab = forgeProvider("gitlab");
|
|
1634
|
-
|
|
1635
|
-
//#region ../browser/src/host.ts
|
|
2861
|
+
// ../browser/src/host.ts
|
|
1636
2862
|
var current = null;
|
|
1637
2863
|
function getBrowserHost() {
|
|
1638
2864
|
if (!current) throw new Error("No browser host configured");
|
|
1639
2865
|
return current;
|
|
1640
2866
|
}
|
|
1641
|
-
|
|
1642
|
-
//#region ../browser/src/proofs/oidc/jwks.ts
|
|
2867
|
+
// ../browser/src/proofs/oidc/jwks.ts
|
|
1643
2868
|
/**
|
|
1644
2869
|
* A provider's signing keys, fetched from its pinned JWKS URL with limits and
|
|
1645
2870
|
* cached. A key ID that is not in the cached set triggers one early refetch
|
|
@@ -1886,8 +3111,7 @@ async function verifyIdToken(token, options) {
|
|
|
1886
3111
|
tenant: provider.id === "microsoft" ? text(claims.tid, 64) : void 0
|
|
1887
3112
|
};
|
|
1888
3113
|
}
|
|
1889
|
-
|
|
1890
|
-
//#region ../browser/src/proofs/oidc/flow.ts
|
|
3114
|
+
// ../browser/src/proofs/oidc/flow.ts
|
|
1891
3115
|
/** Optional platform prefix (desktop `d.<port>.`, Android deep link `a.`), then 32 random bytes. */
|
|
1892
3116
|
var STATE = /^(?:d\.\d{1,5}\.|a\.)?[A-Za-z0-9_-]{43}$/;
|
|
1893
3117
|
function scopeFor$1(provider, reveal) {
|
|
@@ -2035,8 +3259,7 @@ function refuseUnchosenClaims(provider, idToken, reveal) {
|
|
|
2035
3259
|
throw new Error(claim === "hd" ? `This is a work or school ${provider.name} account: ${provider.name} adds its organisation’s domain to the sign-in, and your contacts would see it. Choose to share your email too, or sign in with a personal account.` : `${provider.name} added more to the sign-in than you chose to share. Choose to share your ${coveredBy} too, or sign in with another account.`);
|
|
2036
3260
|
}
|
|
2037
3261
|
}
|
|
2038
|
-
|
|
2039
|
-
//#region ../browser/src/proofs/providers/oidc.ts
|
|
3262
|
+
// ../browser/src/proofs/providers/oidc.ts
|
|
2040
3263
|
/** How long after the statement the sign-in may have happened: time to pick an account and approve. */
|
|
2041
3264
|
var SIGN_IN_WINDOW = 900;
|
|
2042
3265
|
var TOKEN = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
|
|
@@ -2176,8 +3399,7 @@ function createOidcIdentityProvider(options = {}) {
|
|
|
2176
3399
|
};
|
|
2177
3400
|
}
|
|
2178
3401
|
var oidc = createOidcIdentityProvider();
|
|
2179
|
-
|
|
2180
|
-
//#region ../browser/src/proofs/did.ts
|
|
3402
|
+
// ../browser/src/proofs/did.ts
|
|
2181
3403
|
/** Resolutions are shared for this long: back-to-back checks and the add dialog's preview, never a stale key for long. */
|
|
2182
3404
|
var CACHE_MS = 3e4;
|
|
2183
3405
|
var cache = /* @__PURE__ */ new Map();
|
|
@@ -2282,8 +3504,7 @@ async function resolveDid(input, options) {
|
|
|
2282
3504
|
async function fetchDidWebFile(did, proofId, options) {
|
|
2283
3505
|
return fetchDidWeb(did, didWebFileUrl(did, proofId), DID_FILE_MAX_BYTES, options);
|
|
2284
3506
|
}
|
|
2285
|
-
|
|
2286
|
-
//#region ../browser/src/proofs/providers/did.ts
|
|
3507
|
+
// ../browser/src/proofs/providers/did.ts
|
|
2287
3508
|
var VM = /^did:[a-z0-9]+:[\x21-\x7e]+#[\x21-\x7e]+$/;
|
|
2288
3509
|
var SIG = /^[A-Za-z0-9_-]{86}$/;
|
|
2289
3510
|
var exactKeys$1 = (raw, keys) => !!raw && typeof raw === "object" && !Array.isArray(raw) && Object.keys(raw).sort().join(",") === keys;
|
|
@@ -2594,8 +3815,7 @@ var did = {
|
|
|
2594
3815
|
};
|
|
2595
3816
|
}
|
|
2596
3817
|
};
|
|
2597
|
-
|
|
2598
|
-
//#region ../browser/src/proofs/atproto/oauth.ts
|
|
3818
|
+
// ../browser/src/proofs/atproto/oauth.ts
|
|
2599
3819
|
/**
|
|
2600
3820
|
* The prover's half of AT Protocol proofs: AT Protocol OAuth (PAR + PKCE + DPoP, through the official
|
|
2601
3821
|
* `@atproto/oauth-client`) against the person's own server, then one record written or deleted. Every
|
|
@@ -2851,8 +4071,7 @@ async function unpublishAtprotoProof(proofKey, options) {
|
|
|
2851
4071
|
if (!response.ok) throw new Error(`Your server did not delete the record (${await xrpcError(response)}).`);
|
|
2852
4072
|
});
|
|
2853
4073
|
}
|
|
2854
|
-
|
|
2855
|
-
//#region ../browser/src/proofs/providers/atproto.ts
|
|
4074
|
+
// ../browser/src/proofs/providers/atproto.ts
|
|
2856
4075
|
/** The proof CAR: a commit, the tree path and one small record. Real repositories' paths are a few KiB. */
|
|
2857
4076
|
var RECORD_PROOF_MAX_BYTES = 262144;
|
|
2858
4077
|
function currentHost() {
|
|
@@ -3049,8 +4268,7 @@ function createAtprotoIdentityProvider(options = {}) {
|
|
|
3049
4268
|
};
|
|
3050
4269
|
}
|
|
3051
4270
|
var atproto = createAtprotoIdentityProvider();
|
|
3052
|
-
|
|
3053
|
-
//#region ../browser/src/proofs/pubky.ts
|
|
4271
|
+
// ../browser/src/proofs/pubky.ts
|
|
3054
4272
|
/**
|
|
3055
4273
|
* Pubky, browser side: reading a key's records and files the way a contact's app does (through the proof
|
|
3056
4274
|
* contract's bounded `ctx.fetch` only), and asking the person to approve one Pubky auth request in Pubky Ring or
|
|
@@ -3428,8 +4646,7 @@ async function approveAndWork(options, work, { grant, cookie, opened, settled, c
|
|
|
3428
4646
|
approved.free();
|
|
3429
4647
|
}
|
|
3430
4648
|
}
|
|
3431
|
-
|
|
3432
|
-
//#region ../browser/src/proofs/providers/pubky.ts
|
|
4649
|
+
// ../browser/src/proofs/providers/pubky.ts
|
|
3433
4650
|
var short = (key) => `pubky${key.slice(0, 4)}…${key.slice(-4)}`;
|
|
3434
4651
|
/** Strict: exactly `{ folder }`, 64 hex characters. Nothing else, so no evidence can name a host or another path. */
|
|
3435
4652
|
function parseEvidence(raw) {
|
|
@@ -3539,7 +4756,7 @@ var testIdentitiesEnabled = () => {
|
|
|
3539
4756
|
}
|
|
3540
4757
|
};
|
|
3541
4758
|
var HEX64 = /^[a-f0-9]{64}$/;
|
|
3542
|
-
var hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
|
|
4759
|
+
var hex$1 = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
|
|
3543
4760
|
var unhex = (s) => Uint8Array.from(s.match(/../g), (x) => parseInt(x, 16));
|
|
3544
4761
|
var normalizeHexKey = (input) => {
|
|
3545
4762
|
const v = input.trim().toLowerCase();
|
|
@@ -3557,7 +4774,7 @@ var fakeKeyring = {
|
|
|
3557
4774
|
fakeSeed = value;
|
|
3558
4775
|
}
|
|
3559
4776
|
};
|
|
3560
|
-
var fakeKeySubject = (seed = fakeKeyring.seed) => hex(ed25519.getPublicKey(seed));
|
|
4777
|
+
var fakeKeySubject = (seed = fakeKeyring.seed) => hex$1(ed25519.getPublicKey(seed));
|
|
3561
4778
|
var fakeKeySign = (statement, seed = fakeKeyring.seed) => ({ sig: toBase64Url(ed25519.sign(statement.bytes, seed)) });
|
|
3562
4779
|
var fakeKey = {
|
|
3563
4780
|
id: "fake-key",
|
|
@@ -3756,8 +4973,7 @@ var FAKE_IDENTITY_PROVIDERS = [
|
|
|
3756
4973
|
}
|
|
3757
4974
|
}
|
|
3758
4975
|
];
|
|
3759
|
-
|
|
3760
|
-
//#region ../browser/src/proofs/registry.ts
|
|
4976
|
+
// ../browser/src/proofs/registry.ts
|
|
3761
4977
|
/**
|
|
3762
4978
|
* Every identity-proof provider built into Ghostly. Adding one is adding its module under `providers/`
|
|
3763
4979
|
* and ONE line here; see PROOFS.md. The order is the order of the picker on the Identities page. A
|
|
@@ -3797,7 +5013,6 @@ function identityProviders() {
|
|
|
3797
5013
|
function identityProvider(id, providers = identityProviders()) {
|
|
3798
5014
|
return providers.find((p) => p.id === id);
|
|
3799
5015
|
}
|
|
3800
|
-
|
|
3801
|
-
export { identityProvider as n, identityProviders as r, IDENTITY_PROVIDERS as t };
|
|
5016
|
+
export { parseProofBunker as i, identityProvider as n, identityProviders as r, IDENTITY_PROVIDERS as t };
|
|
3802
5017
|
|
|
3803
|
-
//# sourceMappingURL=registry-
|
|
5018
|
+
//# sourceMappingURL=registry-rXgaZeNn.js.map
|