fix: use %w instead of %s

Author: alanshaw

client/connection.go

@@ -105,22 +105,22 @@ type ExecutionResponse interface {
 func Execute(ctx context.Context, invocations []invocation.Invocation, conn Connection) (ExecutionResponse, error) {
 	input, err := message.Build(invocations, nil)
 	if err != nil {
-		return nil, fmt.Errorf("building message: %s", err)
+		return nil, fmt.Errorf("building message: %w", err)
 	}
 
 	req, err := conn.Codec().Encode(input)
 	if err != nil {
-		return nil, fmt.Errorf("encoding message: %s", err)
+		return nil, fmt.Errorf("encoding message: %w", err)
 	}
 
 	res, err := conn.Channel().Request(ctx, req)
 	if err != nil {
-		return nil, fmt.Errorf("sending message: %s", err)
+		return nil, fmt.Errorf("sending message: %w", err)
 	}
 
 	output, err := conn.Codec().Decode(res)
 	if err != nil {
-		return nil, fmt.Errorf("decoding message: %s", err)
+		return nil, fmt.Errorf("decoding message: %w", err)
 	}
 
 	return ExecutionResponse(output), nil

core/car/car.go

@@ -27,7 +27,7 @@ func Encode(roots []ipld.Link, blocks iter.Seq2[ipld.Block, error]) io.Reader {
 		for _, r := range roots {
 			_, cid, err := cid.CidFromBytes([]byte(r.Binary()))
 			if err != nil {
-				writer.CloseWithError(fmt.Errorf("decoding CAR root: %s: %s", r, err))
+				writer.CloseWithError(fmt.Errorf("decoding CAR root: %s: %w", r, err))
 				return
 			}
 			cids = append(cids, cid)
@@ -38,18 +38,18 @@ func Encode(roots []ipld.Link, blocks iter.Seq2[ipld.Block, error]) io.Reader {
 		}
 		hb, err := cbor.DumpObject(h)
 		if err != nil {
-			writer.CloseWithError(fmt.Errorf("writing CAR header: %s", err))
+			writer.CloseWithError(fmt.Errorf("writing CAR header: %w", err))
 			return
 		}
 		util.LdWrite(writer, hb)
 		for block, err := range blocks {
 			if err != nil {
-				writer.CloseWithError(fmt.Errorf("writing CAR blocks: %s", err))
+				writer.CloseWithError(fmt.Errorf("writing CAR blocks: %w", err))
 				return
 			}
 			err = util.LdWrite(writer, []byte(block.Link().Binary()), block.Bytes())
 			if err != nil {
-				writer.CloseWithError(fmt.Errorf("writing CAR blocks: %s", err))
+				writer.CloseWithError(fmt.Errorf("writing CAR blocks: %w", err))
 				return
 			}
 		}

core/dag/blockstore/blockstore.go

@@ -187,7 +187,7 @@ func WriteInto(view ipld.View, bs BlockWriter) error {
 	for b := range view.Blocks() {
 		err := bs.Put(b)
 		if err != nil {
-			return fmt.Errorf("putting proof block: %s", err)
+			return fmt.Errorf("putting proof block: %w", err)
 		}
 	}
 	return nil

core/delegation/datamodel/archive.go

@@ -23,7 +23,7 @@ func mustLoadSchema() *schema.TypeSystem {
 		ts, err = ipld.LoadSchemaBytes(archive)
 	})
 	if err != nil {
-		panic(fmt.Errorf("failed to load IPLD schema: %s", err))
+		panic(fmt.Errorf("failed to load IPLD schema: %w", err))
 	}
 	return ts
 }

core/delegation/datamodel/archive_test.go

@@ -18,13 +18,13 @@ func TestEncodeDecode(t *testing.T) {
 	}
 	mblk, err := block.Encode(&m0, adm.Type(), cbor.Codec, sha256.Hasher)
 	if err != nil {
-		t.Fatalf("encoding archive model: %s", err)
+		t.Fatalf("encoding archive model: %w", err)
 	}
 
 	m1 := adm.ArchiveModel{}
 	err = block.Decode(mblk, &m1, adm.Type(), cbor.Codec, sha256.Hasher)
 	if err != nil {
-		t.Fatalf("decoding agent message: %s", err)
+		t.Fatalf("decoding agent message: %w", err)
 	}
 
 	d1 := m1.Ucan0_9_1

core/delegation/delegate.go

@@ -116,17 +116,17 @@ func Delegate[C ucan.CaveatBuilder](issuer ucan.Signer, audience ucan.Principal,
 
 	data, err := ucan.Issue(issuer, audience, capabilities, opts...)
 	if err != nil {
-		return nil, fmt.Errorf("issuing UCAN: %s", err)
+		return nil, fmt.Errorf("issuing UCAN: %w", err)
 	}
 
 	rt, err := block.Encode(data.Model(), udm.Type(), cbor.Codec, sha256.Hasher)
 	if err != nil {
-		return nil, fmt.Errorf("encoding UCAN: %s", err)
+		return nil, fmt.Errorf("encoding UCAN: %w", err)
 	}
 
 	err = bs.Put(rt)
 	if err != nil {
-		return nil, fmt.Errorf("adding delegation root to store: %s", err)
+		return nil, fmt.Errorf("adding delegation root to store: %w", err)
 	}
 
 	return NewDelegation(rt, bs)

core/delegation/delegation.go

@@ -115,7 +115,7 @@ func (d *delegation) Attach(b block.Block) error {
 func NewDelegation(root ipld.Block, bs blockstore.BlockReader) (Delegation, error) {
 	ucan, err := decode(root)
 	if err != nil {
-		return nil, fmt.Errorf("decoding UCAN: %s", err)
+		return nil, fmt.Errorf("decoding UCAN: %w", err)
 	}
 	attachments, err := blockstore.NewBlockStore()
 	if err != nil {
@@ -127,7 +127,7 @@ func NewDelegation(root ipld.Block, bs blockstore.BlockReader) (Delegation, erro
 func NewDelegationView(root ipld.Link, bs blockstore.BlockReader) (Delegation, error) {
 	blk, ok, err := bs.Get(root)
 	if err != nil {
-		return nil, fmt.Errorf("getting delegation root block: %s", err)
+		return nil, fmt.Errorf("getting delegation root block: %w", err)
 	}
 	if !ok {
 		return nil, fmt.Errorf("missing delegation root block: %s", root)
@@ -201,20 +201,20 @@ func Archive(d Delegation) io.Reader {
 	)
 	if err != nil {
 		reader, _ := io.Pipe()
-		reader.CloseWithError(fmt.Errorf("hashing variant block bytes: %s", err))
+		reader.CloseWithError(fmt.Errorf("hashing variant block bytes: %w", err))
 		return reader
 	}
 	// Create a new reader that contains the new block as well as the others.
 	blks, err := blockstore.NewBlockStore(blockstore.WithBlocksIterator(d.Blocks()))
 	if err != nil {
 		reader, _ := io.Pipe()
-		reader.CloseWithError(fmt.Errorf("creating new block reader: %s", err))
+		reader.CloseWithError(fmt.Errorf("creating new block reader: %w", err))
 		return reader
 	}
 	err = blks.Put(variant)
 	if err != nil {
 		reader, _ := io.Pipe()
-		reader.CloseWithError(fmt.Errorf("adding variant block: %s", err))
+		reader.CloseWithError(fmt.Errorf("adding variant block: %w", err))
 		return reader
 	}
 	return car.Encode([]ipld.Link{variant.Link()}, blks.Iterator())
@@ -234,15 +234,15 @@ func Extract(b []byte) (Delegation, error) {
 
 	br, err := blockstore.NewBlockReader(blockstore.WithBlocksIterator(blks))
 	if err != nil {
-		return nil, fmt.Errorf("creating block reader: %s", err)
+		return nil, fmt.Errorf("creating block reader: %w", err)
 	}
 
 	rt, ok, err := br.Get(roots[0])
 	if err != nil {
-		return nil, fmt.Errorf("getting root block: %s", err)
+		return nil, fmt.Errorf("getting root block: %w", err)
 	}
 	if !ok {
-		return nil, fmt.Errorf("missing root block: %d", len(roots))
+		return nil, fmt.Errorf("missing root block: %s", roots[0])
 	}
 
 	model := adm.ArchiveModel{}
@@ -254,7 +254,7 @@ func Extract(b []byte) (Delegation, error) {
 		sha256.Hasher,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("decoding root block: %s", err)
+		return nil, fmt.Errorf("decoding root block: %w", err)
 	}
 
 	return NewDelegationView(model.Ucan0_9_1, br)

core/message/datamodel/agentmessage.go

@@ -23,7 +23,7 @@ func mustLoadSchema() *schema.TypeSystem {
 		ts, err = ipld.LoadSchemaBytes(agentmessage)
 	})
 	if err != nil {
-		panic(fmt.Errorf("failed to load IPLD schema: %s", err))
+		panic(fmt.Errorf("failed to load IPLD schema: %w", err))
 	}
 	return ts
 }

core/message/message.go

@@ -140,7 +140,7 @@ func NewMessage(roots []ipld.Link, blks blockstore.BlockReader) (AgentMessage, e
 
 	rblock, ok, err := blks.Get(roots[0])
 	if err != nil {
-		return nil, fmt.Errorf("getting root block: %s", err)
+		return nil, fmt.Errorf("getting root block: %w", err)
 	}
 	if !ok {
 		return nil, fmt.Errorf("missing root block: %s", roots[0])
@@ -155,7 +155,7 @@ func NewMessage(roots []ipld.Link, blks blockstore.BlockReader) (AgentMessage, e
 		sha256.Hasher,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("decoding message: %s", err)
+		return nil, fmt.Errorf("decoding message: %w", err)
 	}
 
 	return &message{root: rblock, data: msg.UcantoMessage7, blks: blks}, nil

core/receipt/datamodel/receipt.go

@@ -24,7 +24,7 @@ var anyReceiptTs *schema.TypeSystem
 func init() {
 	ts, err := NewReceiptModelType(anyResultSchema)
 	if err != nil {
-		panic(fmt.Errorf("failed to load IPLD schema: %s", err))
+		panic(fmt.Errorf("failed to load IPLD schema: %w", err))
 	}
 	anyReceiptTs = ts.TypeSystem()
 }