@helia/bitswap 4.0.18 → 4.0.19-bdbda7ae

package/src/pb/message.ts

@@ -14,7 +14,7 @@ enum __WantTypeValues {
 }
 
 export namespace WantType {
-  export const codec = (): Codec<WantType> => {
+  export const codec = (): Codec<WantType, WantType> => {
     return enumeration<WantType>(__WantTypeValues)
   }
 }
@@ -27,12 +27,20 @@ export interface WantlistEntry {
   sendDontHave?: boolean
 }
 
+export interface WantlistEntryInput {
+  cid?: Uint8Array
+  priority?: number
+  cancel?: boolean
+  wantType?: WantType
+  sendDontHave?: boolean
+}
+
 export namespace WantlistEntry {
-  let _codec: Codec<WantlistEntry>
+  let _codec: Codec<WantlistEntry, WantlistEntryInput>
 
-  export const codec = (): Codec<WantlistEntry> => {
+  export const codec = (): Codec<WantlistEntry, WantlistEntryInput> => {
     if (_codec == null) {
-      _codec = message<WantlistEntry>((obj, w, opts = {}) => {
+      _codec = message<WantlistEntry, WantlistEntryInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -65,48 +73,48 @@ export namespace WantlistEntry {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length, opts = {}) => {
+      }, (r, length) => {
         const obj: any = {
           cid: uint8ArrayAlloc(0),
           priority: 0
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
-              obj.cid = reader.bytes()
+              obj.cid = r.bytes()
               break
             }
             case 2: {
-              obj.priority = reader.int32()
+              obj.priority = r.int32()
               break
             }
             case 3: {
-              obj.cancel = reader.bool()
+              obj.cancel = r.bool()
               break
             }
             case 4: {
-              obj.wantType = WantType.codec().decode(reader)
+              obj.wantType = WantType.codec().decode(r)
               break
             }
             case 5: {
-              obj.sendDontHave = reader.bool()
+              obj.sendDontHave = r.bool()
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
         }
 
         return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const end = length == null ? reader.len : reader.pos + length
+      }, function * (r, length, prefix) {
+        const end = length == null ? r.len : r.pos + length
 
         if (prefix !== '.') {
           yield {
@@ -116,47 +124,47 @@ export namespace WantlistEntry {
           }
         }
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
               yield {
                 field: `${prefix}cid`,
-                value: reader.bytes()
+                value: r.bytes()
               }
               break
             }
             case 2: {
               yield {
                 field: `${prefix}priority`,
-                value: reader.int32()
+                value: r.int32()
               }
               break
             }
             case 3: {
               yield {
                 field: `${prefix}cancel`,
-                value: reader.bool()
+                value: r.bool()
               }
               break
             }
             case 4: {
               yield {
                 field: `${prefix}wantType`,
-                value: WantType.codec().decode(reader)
+                value: WantType.codec().decode(r)
               }
               break
             }
             case 5: {
               yield {
                 field: `${prefix}sendDontHave`,
-                value: reader.bool()
+                value: r.bool()
               }
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
@@ -200,7 +208,7 @@ export namespace WantlistEntry {
     value: boolean
   }
 
-  export function encode (obj: Partial<WantlistEntry>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: WantlistEntryInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, WantlistEntry.codec())
   }
 
@@ -218,12 +226,17 @@ export interface Wantlist {
   full?: boolean
 }
 
+export interface WantlistInput {
+  entries?: WantlistEntryInput[]
+  full?: boolean
+}
+
 export namespace Wantlist {
-  let _codec: Codec<Wantlist>
+  let _codec: Codec<Wantlist, WantlistInput>
 
-  export const codec = (): Codec<Wantlist> => {
+  export const codec = (): Codec<Wantlist, WantlistInput> => {
     if (_codec == null) {
-      _codec = message<Wantlist>((obj, w, opts = {}) => {
+      _codec = message<Wantlist, WantlistInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -243,15 +256,15 @@ export namespace Wantlist {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length, opts = {}) => {
+      }, (r, length, opts = {}) => {
         const obj: any = {
           entries: []
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
@@ -259,29 +272,29 @@ export namespace Wantlist {
                 throw new MaxLengthError('Decode error - repeated field "entries" had too many elements')
               }
 
-              obj.entries.push(WantlistEntry.codec().decode(reader, reader.uint32(), {
+              obj.entries.push(WantlistEntry.codec().decode(r, r.uint32(), {
                 limits: opts.limits?.entries$
               }))
               break
             }
             case 2: {
-              obj.full = reader.bool()
+              obj.full = r.bool()
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
         }
 
         return obj
-      }, function * (reader, length, prefix, opts = {}) {
+      }, function * (r, length, prefix, opts = {}) {
         const obj = {
           entries: 0
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
         if (prefix !== '.') {
           yield {
@@ -291,8 +304,8 @@ export namespace Wantlist {
           }
         }
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
@@ -300,7 +313,7 @@ export namespace Wantlist {
                 throw new MaxLengthError('Streaming decode error - repeated field "entries" had too many elements')
               }
 
-              for (const evt of WantlistEntry.codec().stream(reader, reader.uint32(), `${prefix}entries[].`, {
+              for (const evt of WantlistEntry.codec().stream(r, r.uint32(), `${prefix}entries[].`, {
                 limits: opts.limits?.entries$
               })) {
                 yield {
@@ -316,12 +329,12 @@ export namespace Wantlist {
             case 2: {
               yield {
                 field: `${prefix}full`,
-                value: reader.bool()
+                value: r.bool()
               }
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
@@ -389,7 +402,7 @@ export namespace Wantlist {
     value: boolean
   }
 
-  export function encode (obj: Partial<Wantlist>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: WantlistInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Wantlist.codec())
   }
 
@@ -407,12 +420,17 @@ export interface Block {
   data: Uint8Array<ArrayBuffer>
 }
 
+export interface BlockInput {
+  prefix?: Uint8Array
+  data?: Uint8Array
+}
+
 export namespace Block {
-  let _codec: Codec<Block>
+  let _codec: Codec<Block, BlockInput>
 
-  export const codec = (): Codec<Block> => {
+  export const codec = (): Codec<Block, BlockInput> => {
     if (_codec == null) {
-      _codec = message<Block>((obj, w, opts = {}) => {
+      _codec = message<Block, BlockInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -430,36 +448,36 @@ export namespace Block {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length, opts = {}) => {
+      }, (r, length) => {
         const obj: any = {
           prefix: uint8ArrayAlloc(0),
           data: uint8ArrayAlloc(0)
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
-              obj.prefix = reader.bytes()
+              obj.prefix = r.bytes()
               break
             }
             case 2: {
-              obj.data = reader.bytes()
+              obj.data = r.bytes()
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
         }
 
         return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const end = length == null ? reader.len : reader.pos + length
+      }, function * (r, length, prefix) {
+        const end = length == null ? r.len : r.pos + length
 
         if (prefix !== '.') {
           yield {
@@ -469,26 +487,26 @@ export namespace Block {
           }
         }
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
               yield {
                 field: `${prefix}prefix`,
-                value: reader.bytes()
+                value: r.bytes()
               }
               break
             }
             case 2: {
               yield {
                 field: `${prefix}data`,
-                value: reader.bytes()
+                value: r.bytes()
               }
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
@@ -517,7 +535,7 @@ export namespace Block {
     value: Uint8Array<ArrayBuffer>
   }
 
-  export function encode (obj: Partial<Block>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: BlockInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, Block.codec())
   }
 
@@ -541,7 +559,7 @@ enum __BlockPresenceTypeValues {
 }
 
 export namespace BlockPresenceType {
-  export const codec = (): Codec<BlockPresenceType> => {
+  export const codec = (): Codec<BlockPresenceType, BlockPresenceType> => {
     return enumeration<BlockPresenceType>(__BlockPresenceTypeValues)
   }
 }
@@ -551,12 +569,17 @@ export interface BlockPresence {
   type: BlockPresenceType
 }
 
+export interface BlockPresenceInput {
+  cid?: Uint8Array
+  type?: BlockPresenceType
+}
+
 export namespace BlockPresence {
-  let _codec: Codec<BlockPresence>
+  let _codec: Codec<BlockPresence, BlockPresenceInput>
 
-  export const codec = (): Codec<BlockPresence> => {
+  export const codec = (): Codec<BlockPresence, BlockPresenceInput> => {
     if (_codec == null) {
-      _codec = message<BlockPresence>((obj, w, opts = {}) => {
+      _codec = message<BlockPresence, BlockPresenceInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -574,36 +597,36 @@ export namespace BlockPresence {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length, opts = {}) => {
+      }, (r, length) => {
         const obj: any = {
           cid: uint8ArrayAlloc(0),
           type: BlockPresenceType.HaveBlock
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
-              obj.cid = reader.bytes()
+              obj.cid = r.bytes()
               break
             }
             case 2: {
-              obj.type = BlockPresenceType.codec().decode(reader)
+              obj.type = BlockPresenceType.codec().decode(r)
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
         }
 
         return obj
-      }, function * (reader, length, prefix, opts = {}) {
-        const end = length == null ? reader.len : reader.pos + length
+      }, function * (r, length, prefix) {
+        const end = length == null ? r.len : r.pos + length
 
         if (prefix !== '.') {
           yield {
@@ -613,26 +636,26 @@ export namespace BlockPresence {
           }
         }
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
               yield {
                 field: `${prefix}cid`,
-                value: reader.bytes()
+                value: r.bytes()
               }
               break
             }
             case 2: {
               yield {
                 field: `${prefix}type`,
-                value: BlockPresenceType.codec().decode(reader)
+                value: BlockPresenceType.codec().decode(r)
               }
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
@@ -661,7 +684,7 @@ export namespace BlockPresence {
     value: BlockPresenceType
   }
 
-  export function encode (obj: Partial<BlockPresence>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: BlockPresenceInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, BlockPresence.codec())
   }
 
@@ -681,12 +704,19 @@ export interface BitswapMessage {
   pendingBytes: number
 }
 
+export interface BitswapMessageInput {
+  wantlist?: WantlistInput
+  blocks?: BlockInput[]
+  blockPresences?: BlockPresenceInput[]
+  pendingBytes?: number
+}
+
 export namespace BitswapMessage {
-  let _codec: Codec<BitswapMessage>
+  let _codec: Codec<BitswapMessage, BitswapMessageInput>
 
-  export const codec = (): Codec<BitswapMessage> => {
+  export const codec = (): Codec<BitswapMessage, BitswapMessageInput> => {
     if (_codec == null) {
-      _codec = message<BitswapMessage>((obj, w, opts = {}) => {
+      _codec = message<BitswapMessage, BitswapMessageInput>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
           w.fork()
         }
@@ -718,21 +748,21 @@ export namespace BitswapMessage {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length, opts = {}) => {
+      }, (r, length, opts = {}) => {
         const obj: any = {
           blocks: [],
           blockPresences: [],
           pendingBytes: 0
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
-              obj.wantlist = Wantlist.codec().decode(reader, reader.uint32(), {
+              obj.wantlist = Wantlist.codec().decode(r, r.uint32(), {
                 limits: opts.limits?.wantlist
               })
               break
@@ -742,7 +772,7 @@ export namespace BitswapMessage {
                 throw new MaxLengthError('Decode error - repeated field "blocks" had too many elements')
               }
 
-              obj.blocks.push(Block.codec().decode(reader, reader.uint32(), {
+              obj.blocks.push(Block.codec().decode(r, r.uint32(), {
                 limits: opts.limits?.blocks$
               }))
               break
@@ -752,30 +782,30 @@ export namespace BitswapMessage {
                 throw new MaxLengthError('Decode error - repeated field "blockPresences" had too many elements')
               }
 
-              obj.blockPresences.push(BlockPresence.codec().decode(reader, reader.uint32(), {
+              obj.blockPresences.push(BlockPresence.codec().decode(r, r.uint32(), {
                 limits: opts.limits?.blockPresences$
               }))
               break
             }
             case 5: {
-              obj.pendingBytes = reader.int32()
+              obj.pendingBytes = r.int32()
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
         }
 
         return obj
-      }, function * (reader, length, prefix, opts = {}) {
+      }, function * (r, length, prefix, opts = {}) {
         const obj = {
           blocks: 0,
           blockPresences: 0
         }
 
-        const end = length == null ? reader.len : reader.pos + length
+        const end = length == null ? r.len : r.pos + length
 
         if (prefix !== '.') {
           yield {
@@ -785,12 +815,12 @@ export namespace BitswapMessage {
           }
         }
 
-        while (reader.pos < end) {
-          const tag = reader.uint32()
+        while (r.pos < end) {
+          const tag = r.uint32()
 
           switch (tag >>> 3) {
             case 1: {
-              yield * Wantlist.codec().stream(reader, reader.uint32(), `${prefix}wantlist.`, {
+              yield * Wantlist.codec().stream(r, r.uint32(), `${prefix}wantlist.`, {
                 limits: opts.limits?.wantlist
               })
 
@@ -801,7 +831,7 @@ export namespace BitswapMessage {
                 throw new MaxLengthError('Streaming decode error - repeated field "blocks" had too many elements')
               }
 
-              for (const evt of Block.codec().stream(reader, reader.uint32(), `${prefix}blocks[].`, {
+              for (const evt of Block.codec().stream(r, r.uint32(), `${prefix}blocks[].`, {
                 limits: opts.limits?.blocks$
               })) {
                 yield {
@@ -819,7 +849,7 @@ export namespace BitswapMessage {
                 throw new MaxLengthError('Streaming decode error - repeated field "blockPresences" had too many elements')
               }
 
-              for (const evt of BlockPresence.codec().stream(reader, reader.uint32(), `${prefix}blockPresences[].`, {
+              for (const evt of BlockPresence.codec().stream(r, r.uint32(), `${prefix}blockPresences[].`, {
                 limits: opts.limits?.blockPresences$
               })) {
                 yield {
@@ -835,12 +865,12 @@ export namespace BitswapMessage {
             case 5: {
               yield {
                 field: `${prefix}pendingBytes`,
-                value: reader.int32()
+                value: r.int32()
               }
               break
             }
             default: {
-              reader.skipType(tag & 7)
+              r.skipType(tag & 7)
               break
             }
           }
@@ -975,7 +1005,7 @@ export namespace BitswapMessage {
     value: number
   }
 
-  export function encode (obj: Partial<BitswapMessage>): Uint8Array<ArrayBuffer> {
+  export function encode (obj: BitswapMessageInput): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, BitswapMessage.codec())
   }
 

package/src/peer-want-lists/ledger.ts

@@ -274,8 +274,20 @@ export class Ledger {
 
   public hasWant (cid: CID): boolean {
     const cidStr = uint8ArrayToString(cid.multihash.bytes, 'base64')
+    const want = this.wants.get(cidStr)
 
-    return this.wants.has(cidStr)
+    if (want == null) {
+      return false
+    }
+
+    // if `haveBlock` is `false` then we previously searched the blockstore for
+    // this block and did not find it - hasWant is called when a new block has
+    // been added to the blockstore so it should now be present - reset the
+    // `haveBlock` field so we attempt to pull it from the blockstore while
+    // sending blocks to the peer
+    delete want.haveBlock
+
+    return true
   }
 
   public queueSendOperation (message?: BitswapMessage, options?: ProgressOptions<BitswapNotifyProgressEvents> & AbortOptions): void {
@@ -318,6 +330,12 @@ export class Ledger {
     // pick unsent wants
     const unsent = [...this.wants.entries()]
       .filter(([key, value]) => {
+        // we have previously searched the blockstore for this block and it was
+        // not present so don't check again
+        if (value.haveBlock === false) {
+          return false
+        }
+
         // don't process the same want more than once per send iteration
         return value.status === 'want'
       })