tap-caip 0.1.0

Chain Agnostic Identifier Protocol Implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

# TAP CAIP

Implementation of Chain Agnostic Identifier Standards for the Transaction Authorization Protocol (TAP).

## Features

- **CAIP-2**: Support for Chain IDs in namespace:reference format
- **CAIP-10**: Support for Account IDs 
- **CAIP-19**: Support for Asset IDs
- **Validation**: Proper validation of identifiers against the CAIP specifications
- **Parsing and Serialization**: Easy conversion between strings and structured types

## Usage

### Chain ID (CAIP-2)

```rust
use tap_caip::ChainId;
use std::str::FromStr;

// Create from string
let chain_id = ChainId::from_str("eip155:1")?;

// Access components
assert_eq!(chain_id.namespace, "eip155");
assert_eq!(chain_id.reference, "1");

// Convert back to string
assert_eq!(chain_id.to_string(), "eip155:1");
```

### Account ID (CAIP-10)

```rust
use tap_caip::{AccountId, ChainId};
use std::str::FromStr;

// Create from string
let account_id = AccountId::from_str("eip155:1:0x7c47c2532f745a59e405711020c59d8d2d650136")?;

// Create from components
let chain_id = ChainId::from_str("eip155:1")?;
let account_id = AccountId::new(chain_id, "0x7c47c2532f745a59e405711020c59d8d2d650136");

// Access components
assert_eq!(account_id.chain_id.namespace, "eip155");
assert_eq!(account_id.chain_id.reference, "1");
assert_eq!(account_id.address, "0x7c47c2532f745a59e405711020c59d8d2d650136");

// Convert back to string
assert_eq!(account_id.to_string(), "eip155:1:0x7c47c2532f745a59e405711020c59d8d2d650136");
```

### Asset ID (CAIP-19)

```rust
use tap_caip::{AssetId, ChainId};
use std::str::FromStr;

// Create from string
let asset_id = AssetId::from_str("eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7")?;

// Create from components
let chain_id = ChainId::from_str("eip155:1")?;
let asset_id = AssetId::new(
    chain_id,
    "erc20",
    "0xdac17f958d2ee523a2206206994597c13d831ec7"
);

// Access components
assert_eq!(asset_id.chain_id.namespace, "eip155");
assert_eq!(asset_id.chain_id.reference, "1");
assert_eq!(asset_id.asset_namespace, "erc20");
assert_eq!(asset_id.asset_reference, "0xdac17f958d2ee523a2206206994597c13d831ec7");

// Convert back to string
assert_eq!(asset_id.to_string(), "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7");
```

## Validation

Each identifier type includes validation to ensure it conforms to the CAIP standards:

```rust
use tap_caip::{ChainId, AccountId, AssetId};
use std::str::FromStr;

// Valid chain ID
let valid_chain = ChainId::from_str("eip155:1");
assert!(valid_chain.is_ok());

// Invalid chain ID (missing reference)
let invalid_chain = ChainId::from_str("eip155:");
assert!(invalid_chain.is_err());

// Valid account ID
let valid_account = AccountId::from_str("eip155:1:0x1234567890abcdef");
assert!(valid_account.is_ok());

// Invalid account ID (missing address)
let invalid_account = AccountId::from_str("eip155:1:");
assert!(invalid_account.is_err());

// Valid asset ID
let valid_asset = AssetId::from_str("eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7");
assert!(valid_asset.is_ok());

// Invalid asset ID (missing asset reference)
let invalid_asset = AssetId::from_str("eip155:1/erc20:");
assert!(invalid_asset.is_err());
```

## Integration with TAP Messages

The CAIP types are designed to integrate seamlessly with TAP messages:

```rust
use tap_msg::message::types::{Transfer, Participant};
use tap_caip::AssetId;
use std::str::FromStr;
use std::collections::HashMap;

// Create a TAP Transfer message with a CAIP-19 Asset ID
let asset = AssetId::from_str("eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7")?;

let transfer = Transfer {
    asset,
    originator: Participant {
        id: "did:example:123".to_string(),
        role: Some("originator".to_string()),
    },
    beneficiary: Some(Participant {
        id: "did:example:456".to_string(),
        role: Some("beneficiary".to_string()),
    }),
    amount: "100.0".to_string(),
    agents: vec![],
    settlement_id: None,
    memo: Some("Test transfer".to_string()),
    metadata: HashMap::new(),
};
```

## Supported CAIP Standards

- [CAIP-2](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md): Chain ID Specification
- [CAIP-10](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-10.md): Account ID Specification
- [CAIP-19](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md): Asset ID Specification

## Examples

See the [examples directory](./examples) for more detailed examples of using CAIP identifiers.