Registry: support contracts defined by others

[altafan]

Our sdk supports natively default, delegate and vhtlc contracts. It would be super powerful to allow users to define their own contracts and to have a way to add them to those supported by the client's contract manager.

This is exactly the purpose of the contract registry that would come with 3 contract types supported by default and the possibility to add custom ones defined by users.

Ref: https://github.com/arkade-os/ts-sdk/blob/master/src/contracts/handlers/registry.ts

[arkanaai]

Codebase Context

This lives entirely in the contract/ package:

File	Relevance
contract/types.go	Contract struct, PathContext, PathSelection
contract/manager.go	Manager interface + managerImpl — hardcodes &DefaultHandler{} in Load()
contract/default_handler.go	Reference implementation (TypeDefault = "default") with DeriveContract, SelectPath, GetSpendablePaths
contract/handler.go	Keystore interface (wallet subset)
contract/store.go	ContractStore persistence interface

The key bottleneck is in manager.go:Load() (line 73):

h := &DefaultHandler{}

The handler is hard-coded — there's no dispatch on contract type and no way to register custom handlers.

---

Acceptance Criteria

• A Handler interface is defined (covering DeriveContract, SelectPath, GetSpendablePaths) that DefaultHandler already satisfies
• Manager (or its constructor) exposes a way to register additional handlers by type string: e.g. RegisterHandler(typ string, h Handler) or a WithHandlers(...) option on NewManager
• Load() dispatches to the correct handler per stored Contract.Type, skipping (or warning on) unknown types
• NewDefault / any future NewX methods use the registered handler for their type
• Custom handler implementations can live outside the contract/ package (no internal-only types blocking external implementations)
• Existing behaviour for TypeDefault is unchanged; tests pass

---

Suggested Approach

1. Extract a Handler interface in contract/handler.go (or a new contract/contract.go):

   type Handler interface {
       DeriveContract(ctx context.Context, key wallet.KeyRef, cfg *clientTypes.Config) (*Contract, error)
       SelectPath(ctx context.Context, c *Contract, pctx PathContext) (*PathSelection, error)
       GetSpendablePaths(ctx context.Context, c *Contract, pctx PathContext) ([]PathSelection, error)
   }

   DefaultHandler already satisfies this — no changes needed there.

2. Add a handler registry to managerImpl:

   handlers map[string]Handler // type → handler

   Populate it with TypeDefault → &DefaultHandler{} by default.

3. Wire up NewManager to accept optional extra handlers (variadic option or explicit map param).

4. Update Load() to look up h := m.handlers[key.Type] (or default type for new keys).

No schema changes to Contract or ContractStore are needed — Type is already persisted as a string, and Params/Metadata provide arbitrary per-contract storage for handler-specific data.

[tiero]

connected to #150 (comment) comment, I think it will just become pointless to create "hardcoded contract types" if we can reach a point where from a given contract template + parameters (ie. compiler) we can generalize the tx building without being set in stone.

[bitcoin-coder-bob]

working off of #179