@@ -9,14 +9,16 @@ import { OcapnPublicKeyCodec } from './codecs/components.js';
99import { compareByteArrays } from './syrup/compare.js' ;
1010
1111/**
12- * @import { OcapnPublicKeyData , OcapnSignature } from './codecs/components.js'
12+ * @import { OcapnPublicKeyDescriptor , OcapnSignature } from './codecs/components.js'
1313 */
1414
1515const textEncoder = new TextEncoder ( ) ;
1616
1717/**
1818 * @typedef {object } OcapnPublicKey
19+ * @property {Uint8Array } id
1920 * @property {Uint8Array } bytes
21+ * @property {OcapnPublicKeyDescriptor } descriptor
2022 * @property {(msg: Uint8Array, sig: OcapnSignature) => boolean } verify
2123 */
2224
@@ -38,34 +40,71 @@ export const ocapNSignatureToBytes = sig => {
3840} ;
3941
4042/**
41- * @param {Uint8Array } publicKey
42- * @returns {OcapnPublicKey }
43+ * @param {Uint8Array } publicKeyBytes
44+ * @returns {OcapnPublicKeyDescriptor }
4345 */
44- export const makeOcapnPublicKey = publicKey => {
46+ const makePublicKeyDescriptor = publicKeyBytes => {
4547 return {
46- bytes : publicKey ,
48+ type : 'public-key' ,
49+ scheme : 'ecc' ,
50+ curve : 'Ed25519' ,
51+ flags : 'eddsa' ,
52+ q : publicKeyBytes ,
53+ } ;
54+ } ;
55+
56+ /**
57+ * @param {OcapnPublicKeyDescriptor } publicKeyDescriptor
58+ * @returns {Uint8Array }
59+ */
60+ const publicKeyDescriptorToEncodedBytes = publicKeyDescriptor => {
61+ const syrupWriter = makeSyrupWriter ( ) ;
62+ OcapnPublicKeyCodec . write ( publicKeyDescriptor , syrupWriter ) ;
63+ return syrupWriter . getBytes ( ) ;
64+ } ;
65+
66+ /**
67+ * @param {OcapnPublicKeyDescriptor } publicKeyDescriptor
68+ * @returns {Uint8Array }
69+ */
70+ const makePublicKeyIdFromDescriptor = publicKeyDescriptor => {
71+ const publicKeyEncoded =
72+ publicKeyDescriptorToEncodedBytes ( publicKeyDescriptor ) ;
73+ return sha256 ( sha256 ( publicKeyEncoded ) ) ;
74+ } ;
75+
76+ /**
77+ * @param {Uint8Array } publicKeyBytes
78+ * @returns {OcapnPublicKey }
79+ */
80+ export const makeOcapnPublicKey = publicKeyBytes => {
81+ const publicKeyDescriptor = makePublicKeyDescriptor ( publicKeyBytes ) ;
82+ return harden ( {
83+ id : makePublicKeyIdFromDescriptor ( publicKeyDescriptor ) ,
84+ bytes : publicKeyBytes ,
85+ descriptor : publicKeyDescriptor ,
4786 /**
4887 * @param {Uint8Array } msgBytes
4988 * @param {OcapnSignature } ocapnSig
5089 * @returns {boolean }
5190 */
5291 verify : ( msgBytes , ocapnSig ) => {
5392 const sigBytes = ocapNSignatureToBytes ( ocapnSig ) ;
54- return ed25519 . verify ( sigBytes , msgBytes , publicKey ) ;
93+ return ed25519 . verify ( sigBytes , msgBytes , publicKeyBytes ) ;
5594 } ,
56- } ;
95+ } ) ;
5796} ;
5897
5998/**
6099 * @returns {OcapnKeyPair }
61100 */
62101export const makeOcapnKeyPair = ( ) => {
63- const privateKey = ed25519 . utils . randomPrivateKey ( ) ;
64- const publicKey = ed25519 . getPublicKey ( privateKey ) ;
102+ const privateKeyBytes = ed25519 . utils . randomPrivateKey ( ) ;
103+ const publicKeyBytes = ed25519 . getPublicKey ( privateKeyBytes ) ;
65104 return {
66- publicKey : makeOcapnPublicKey ( publicKey ) ,
105+ publicKey : makeOcapnPublicKey ( publicKeyBytes ) ,
67106 sign : msg => {
68- const sigBytes = ed25519 . sign ( msg , privateKey ) ;
107+ const sigBytes = ed25519 . sign ( msg , privateKeyBytes ) ;
69108 return {
70109 type : 'sig-val' ,
71110 scheme : 'eddsa' ,
@@ -77,46 +116,26 @@ export const makeOcapnKeyPair = () => {
77116} ;
78117
79118/**
80- * @param {OcapnPublicKey } publicKey
81- * @returns {OcapnPublicKeyData }
82- */
83- export const publicKeyToPublicKeyData = publicKey => {
84- return {
85- type : 'public-key' ,
86- scheme : 'ecc' ,
87- curve : 'Ed25519' ,
88- flags : 'eddsa' ,
89- q : publicKey . bytes ,
90- } ;
91- } ;
92-
93- /**
94- * @param {OcapnPublicKeyData } publicKeyData
119+ * @param {OcapnPublicKeyDescriptor } publicKeyDescriptor
95120 * @returns {OcapnPublicKey }
96121 */
97- export const publicKeyDataToPublicKey = publicKeyData => {
98- return makeOcapnPublicKey ( publicKeyData . q ) ;
99- } ;
100-
101- /**
102- * @param {OcapnPublicKeyData } publicKeyData
103- * @returns {Uint8Array }
104- */
105- const publicKeyDataToEncodedBytes = publicKeyData => {
106- const syrupWriter = makeSyrupWriter ( ) ;
107- OcapnPublicKeyCodec . write ( publicKeyData , syrupWriter ) ;
108- return syrupWriter . getBytes ( ) ;
109- } ;
110-
111- /**
112- * @param {OcapnPublicKey } publicKey
113- * @returns {Uint8Array }
114- */
115- export const makePublicKeyId = publicKey => {
116- const publicKeyData = publicKeyToPublicKeyData ( publicKey ) ;
117- const publicKeyEncoded = publicKeyDataToEncodedBytes ( publicKeyData ) ;
118- // Double SHA256 hash of the public key
119- return sha256 ( sha256 ( publicKeyEncoded ) ) ;
122+ export const publicKeyDescriptorToPublicKey = publicKeyDescriptor => {
123+ if ( publicKeyDescriptor . type !== 'public-key' ) {
124+ throw new Error ( 'Invalid public key descriptor: Unexpected type' ) ;
125+ }
126+ if ( publicKeyDescriptor . scheme !== 'ecc' ) {
127+ throw new Error ( 'Invalid public key descriptor: Unexpected scheme' ) ;
128+ }
129+ if ( publicKeyDescriptor . curve !== 'Ed25519' ) {
130+ throw new Error ( 'Invalid public key descriptor: Unexpected curve' ) ;
131+ }
132+ if ( publicKeyDescriptor . flags !== 'eddsa' ) {
133+ throw new Error ( 'Invalid public key descriptor: Unexpected flags' ) ;
134+ }
135+ if ( publicKeyDescriptor . q . length !== 32 ) {
136+ throw new Error ( 'Invalid public key descriptor: Unexpected q length' ) ;
137+ }
138+ return makeOcapnPublicKey ( publicKeyDescriptor . q ) ;
120139} ;
121140
122141/**
@@ -125,7 +144,6 @@ export const makePublicKeyId = publicKey => {
125144 * @returns {Uint8Array }
126145 */
127146export const makeSessionId = ( peerIdOne , peerIdTwo ) => {
128- // Calculate the ID of each side using the process described above.
129147 // Sort both IDs based on the resulting octets
130148 const result = compareByteArrays (
131149 peerIdOne ,
0 commit comments