Zap.pm

filter: Statementstmt 88.8% 16 / 18 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 6 / 6 Podpod n/a totaltotal 91.6% 22 / 24 CC 1 SCAR 0.5
CC
1
Cov
89%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.0
« WalletConnect.pm ↑ Summary HttpAuth.pm »
1 package Net::Nostr::Zap;
2  
3 2 ▶use strictures 2;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 2 ▶use Net::Nostr::_ConstructorArgs ();
Subroutine BEGIN: called CC=1 SCAR=0.0
6 2 ▶use Net::Nostr::_URI qw(append_query_params);
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 2 ▶use Carp qw(croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
9 2 ▶use JSON ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 0 ▶use Net::Nostr::Event;
Subroutine BEGIN: called CC=1 SCAR=2.6
11 use Bitcoin::Crypto::Bech32 qw(
12 encode_bech32
13 translate_5to8 translate_8to5
14 );
15 use Crypt::PK::ECC;
16 use Crypt::PK::ECC::Schnorr;
17 use Exporter 'import';
18  
19 our @EXPORT_OK = qw(
20 lud16_to_url
21 encode_lnurl decode_lnurl
22 bolt11_amount
23 callback_url
24 calculate_splits
25 );
26  
27 use Class::Tiny qw(
28 _type
29 p e a k
30 relays amount lnurl content
31 bolt11 description sender preimage
32 );
33  
34 my $HEX64 = qr/\A[0-9a-f]{64}\z/;
35  
36 ###############################################################################
37 # Constructors
38 ###############################################################################
39  
40 sub new_request {
41 my $class = shift;
42 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
43 croak "p is required for zap request" unless defined $args{p};
44 croak "relays is required for zap request" unless $args{relays} && @{$args{relays}};
45 $args{content} //= '';
46 return bless { _type => 'request', %args }, $class;
47 }
48  
49 sub new_receipt {
50 my $class = shift;
51 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
52 croak "p is required for zap receipt" unless defined $args{p};
53 croak "bolt11 is required for zap receipt" unless defined $args{bolt11};
54 croak "description is required for zap receipt" unless defined $args{description};
55 $args{content} //= '';
56 return bless { _type => 'receipt', %args }, $class;
57 }
58  
59 ###############################################################################
60 # Parsing from events
61 ###############################################################################
62  
63 sub request_from_event {
64 my ($class, $event) = @_;
65 croak "event must be kind 9734" unless $event->kind == 9734;
66  
67 my %args = (content => $event->content);
68 my @relays;
69 for my $tag (@{$event->tags}) {
70 next unless @$tag >= 2;
71 my $name = $tag->[0];
72 if ($name eq 'p') { $args{p} = $tag->[1] }
73 elsif ($name eq 'e') { $args{e} = $tag->[1] }
74 elsif ($name eq 'a') { $args{a} = $tag->[1] }
75 elsif ($name eq 'k') { $args{k} = $tag->[1] }
76 elsif ($name eq 'amount') { $args{amount} = $tag->[1] }
77 elsif ($name eq 'lnurl') { $args{lnurl} = $tag->[1] }
78 elsif ($name eq 'relays') { @relays = @{$tag}[1 .. $#$tag] }
79 }
80 $args{relays} = \@relays;
81 return bless { _type => 'request', %args }, $class;
82 }
83  
84 sub receipt_from_event {
85 my ($class, $event) = @_;
86 croak "event must be kind 9735" unless $event->kind == 9735;
87  
88 my %args = (content => $event->content);
89 for my $tag (@{$event->tags}) {
90 next unless @$tag >= 2;
91 my $name = $tag->[0];
92 if ($name eq 'p') { $args{p} = $tag->[1] }
93 elsif ($name eq 'P') { $args{sender} = $tag->[1] }
94 elsif ($name eq 'e') { $args{e} = $tag->[1] }
95 elsif ($name eq 'a') { $args{a} = $tag->[1] }
96 elsif ($name eq 'k') { $args{k} = $tag->[1] }
97 elsif ($name eq 'bolt11') { $args{bolt11} = $tag->[1] }
98 elsif ($name eq 'description') { $args{description} = $tag->[1] }
99 elsif ($name eq 'preimage') { $args{preimage} = $tag->[1] }
100 }
101 return bless { _type => 'receipt', %args }, $class;
102 }
103  
104 ###############################################################################
105 # to_event
106 ###############################################################################
107  
108 sub to_event {
109 my $self = shift;
110 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
111  
112 if ($self->_type eq 'request') {
113 return $self->_request_to_event(%args);
114 } else {
115 return $self->_receipt_to_event(%args);
116 }
117 }
118  
119 sub _request_to_event {
120 my $self = shift;
121 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
122 my @tags;
123 push @tags, ['relays', @{$self->relays}];
124 push @tags, ['amount', $self->amount] if defined $self->amount;
125 push @tags, ['lnurl', $self->lnurl] if defined $self->lnurl;
126 push @tags, ['p', $self->p];
127 push @tags, ['e', $self->e] if defined $self->e;
128 push @tags, ['a', $self->a] if defined $self->a;
129 push @tags, ['k', $self->k] if defined $self->k;
130  
131 return Net::Nostr::Event->new(
132 %args,
133 kind => 9734,
134 content => $self->content // '',
135 tags => \@tags,
136 );
137 }
138  
139 sub _receipt_to_event {
140 my $self = shift;
141 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
142 my @tags;
143 push @tags, ['p', $self->p];
144 push @tags, ['P', $self->sender] if defined $self->sender;
145 push @tags, ['e', $self->e] if defined $self->e;
146 push @tags, ['a', $self->a] if defined $self->a;
147 push @tags, ['k', $self->k] if defined $self->k;
148 push @tags, ['bolt11', $self->bolt11];
149 push @tags, ['description', $self->description];
150 push @tags, ['preimage', $self->preimage] if defined $self->preimage;
151  
152 return Net::Nostr::Event->new(
153 %args,
154 kind => 9735,
155 content => '',
156 tags => \@tags,
157 );
158 }
159  
160 ###############################################################################
161 # zap_request - extract embedded request from receipt description
162 ###############################################################################
163  
164 sub zap_request {
165 my ($self) = @_;
166 croak "zap_request() only available on receipts" unless $self->_type eq 'receipt';
167 my $data = JSON->new->utf8->decode($self->description);
168 return Net::Nostr::Event->new(
169 id => $data->{id},
170 pubkey => $data->{pubkey},
171 created_at => $data->{created_at},
172 kind => $data->{kind},
173 tags => $data->{tags},
174 content => $data->{content},
175 sig => $data->{sig},
176 );
177 }
178  
179 ###############################################################################
180 # Validation
181 ###############################################################################
182  
183 sub validate_request {
184 my ($class, $event, %opts) = @_;
185 croak "event must be kind 9734" unless $event->kind == 9734;
186  
187 # Rule 1: valid signature
188 _verify_sig($event);
189  
190 # Rule 2: must have tags
191 croak "zap request must have tags" unless @{$event->tags};
192  
193 my (@p_tags, @e_tags, @P_tags, @a_tags, @relays_tags, @amount_tags);
194 for my $tag (@{$event->tags}) {
195 my $name = $tag->[0];
196 if ($name eq 'p') { push @p_tags, $tag }
197 elsif ($name eq 'e') { push @e_tags, $tag }
198 elsif ($name eq 'P') { push @P_tags, $tag }
199 elsif ($name eq 'a') { push @a_tags, $tag }
200 elsif ($name eq 'relays') { push @relays_tags, $tag }
201 elsif ($name eq 'amount') { push @amount_tags, $tag }
202 }
203  
204 # Rule 3: exactly one p tag
205 croak "zap request must have exactly one p tag" unless @p_tags == 1;
206  
207 # Rule 4: 0 or 1 e tags
208 croak "zap request must have 0 or 1 e tags" unless @e_tags <= 1;
209  
210 # Rule 5: SHOULD have relays tag
211 warn "zap request missing relays tag\n" unless @relays_tags;
212  
213 # Rule 6: amount tag must match amount query param
214 if (@amount_tags && defined $opts{amount}) {
215 croak "amount tag does not match amount parameter"
216 unless $amount_tags[0][1] eq "$opts{amount}";
217 }
218  
219 # Rule 7: a tag must be valid event coordinate
220 for my $a_tag (@a_tags) {
221 _validate_event_coordinate($a_tag->[1]);
222 }
223  
224 # Rule 8: 0 or 1 P tags; if present, must equal receipt pubkey
225 croak "zap request must have 0 or 1 P tags" unless @P_tags <= 1;
226 if (@P_tags && defined $opts{receipt_pubkey}) {
227 croak "P tag must equal zap receipt pubkey"
228 unless $P_tags[0][1] eq $opts{receipt_pubkey};
229 }
230  
231 return 1;
232 }
233  
234 sub validate_receipt {
235 my ($class, $event, %opts) = @_;
236 croak "event must be kind 9735" unless $event->kind == 9735;
237  
238 my ($p_tag, $bolt11_tag, $desc_tag);
239 for my $tag (@{$event->tags}) {
240 my $name = $tag->[0];
241 if ($name eq 'p') { $p_tag = $tag }
242 elsif ($name eq 'bolt11') { $bolt11_tag = $tag }
243 elsif ($name eq 'description') { $desc_tag = $tag }
244 }
245  
246 croak "zap receipt must have p tag" unless $p_tag;
247 croak "zap receipt must have bolt11 tag" unless $bolt11_tag;
248 croak "zap receipt must have description tag" unless $desc_tag;
249  
250 # Appendix F rule 1: pubkey must equal nostrPubkey
251 if (defined $opts{nostr_pubkey}) {
252 croak "zap receipt pubkey does not match nostrPubkey"
253 unless $event->pubkey eq $opts{nostr_pubkey};
254 }
255  
256 # Appendix F rule 2: invoiceAmount must equal zap request amount
257 my $desc_data = eval { JSON->new->utf8->decode($desc_tag->[1]) };
258 if ($desc_data && $desc_data->{tags}) {
259 my $req_amount;
260 for my $tag (@{$desc_data->{tags}}) {
261 if ($tag->[0] eq 'amount') {
262 $req_amount = $tag->[1];
263 last;
264 }
265 }
266 if (defined $req_amount) {
267 my $invoice_amount = bolt11_amount($bolt11_tag->[1]);
268 if (defined $invoice_amount) {
269 croak "bolt11 invoice amount ($invoice_amount) does not match zap request amount ($req_amount)"
270 unless "$invoice_amount" eq "$req_amount";
271 }
272 }
273  
274 # Appendix F rule 3 (SHOULD): lnurl in request should equal recipient's lnurl
275 if (defined $opts{lnurl}) {
276 my $req_lnurl;
277 for my $tag (@{$desc_data->{tags}}) {
278 if ($tag->[0] eq 'lnurl') {
279 $req_lnurl = $tag->[1];
280 last;
281 }
282 }
283 if (defined $req_lnurl) {
284 warn "zap request lnurl does not match recipient lnurl\n"
285 unless $req_lnurl eq $opts{lnurl};
286 }
287 }
288 }
289  
290 return 1;
291 }
292  
293 sub _verify_sig {
294 my ($event) = @_;
295 croak "zap request has no signature" unless $event->sig;
296 my $sig_raw = eval { pack 'H*', $event->sig };
297 croak "invalid signature format" unless $sig_raw && length($sig_raw) == 64;
298  
299 my $pubkey_raw = pack 'H*', $event->pubkey;
300 # Reconstruct the x-only pubkey in SEC1 compressed format for verification
301 my $pk = Crypt::PK::ECC->new;
302 $pk->import_key_raw("\x02" . $pubkey_raw, 'secp256k1');
303 my $verifier = Crypt::PK::ECC::Schnorr->new(\$pk->export_key_der('public'));
304 croak "invalid zap request signature"
305 unless $verifier->verify_message(pack('H*', $event->id), $sig_raw);
306 }
307  
308 sub _validate_event_coordinate {
309 my ($coord) = @_;
310 # Format: <kind>:<pubkey>:<d-tag>
311 my @parts = split /:/, $coord, 3;
312 croak "invalid event coordinate: must be kind:pubkey:d-tag"
313 unless @parts >= 2;
314 croak "invalid event coordinate: kind must be integer"
315 unless $parts[0] =~ /^\d+$/;
316 croak "invalid event coordinate: pubkey must be 64-char lowercase hex"
317 unless $parts[1] =~ $HEX64;
318 }
319  
320 ###############################################################################
321 # Utility functions
322 ###############################################################################
323  
324 sub lud16_to_url {
325 my ($address) = @_;
326 croak "invalid lightning address" unless defined $address && $address =~ /^([^@]+)@([^@]+)$/;
327 my ($user, $domain) = (lc $1, lc $2);
328 return "https://$domain/.well-known/lnurlp/$user";
329 }
330  
331 {
332 # Reuse Nostr bech32 decode logic for lnurl (same polymod)
333 my @ALPHABET = qw(
334 q p z r y 9 x 8 g f 2 t v d w 0
335 s 3 j n 5 4 k h c e 6 m u a 7 l
336 );
337 my %ALPHABET_MAP = map { $ALPHABET[$_] => $_ } 0 .. $#ALPHABET;
338 my $CHARS = join '', @ALPHABET;
339  
340 sub _polymod {
341 my ($values) = @_;
342 my @C = (0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3);
343 my $chk = 1;
344 for my $val (@$values) {
345 my $b = ($chk >> 25);
346 $chk = ($chk & 0x1ffffff) << 5 ^ $val;
347 for (0 .. 4) { $chk ^= (($b >> $_) & 1) ? $C[$_] : 0 }
348 }
349 return $chk;
350 }
351  
352 sub _hrp_expand {
353 my @hrp = split //, shift;
354 return [map({ ord($_) >> 5 } @hrp), 0, map({ ord($_) & 31 } @hrp)];
355 }
356  
357 sub _lnurl_decode_bech32 {
358 my ($str) = @_;
359 $str = lc $str if uc $str eq $str;
360 croak "invalid bech32 string" if lc($str) ne $str;
361  
362 my @parts = split /1/, $str;
363 croak "bech32 separator missing" if @parts < 2;
364 my $data_part = pop @parts;
365 my $hrp = join '1', @parts;
366  
367 croak "invalid bech32 data characters" if $data_part !~ /\A[$CHARS]+\z/;
368 croak "bech32 data part too short" if length($data_part) < 6;
369  
370 my @data_values = map { $ALPHABET_MAP{$_} } split //, $data_part;
371 my $check_values = [@{_hrp_expand($hrp)}, @data_values];
372 croak "invalid bech32 checksum" unless _polymod($check_values) == 1;
373  
374 my @payload = @data_values[0 .. $#data_values - 6];
375 return ($hrp, \@payload);
376 }
377 }
378  
379 sub encode_lnurl {
380 my ($url) = @_;
381 croak "url is required" unless defined $url;
382 my $bytes = $url; # URL is treated as raw bytes
383 my $data5 = translate_8to5($bytes);
384 return encode_bech32('lnurl', $data5, 'bech32');
385 }
386  
387 sub decode_lnurl {
388 my ($bech32) = @_;
389 croak "expected lnurl prefix" unless defined $bech32 && lc($bech32) =~ /^lnurl1/;
390 my ($hrp, $data5) = _lnurl_decode_bech32($bech32);
391 croak "expected lnurl prefix, got $hrp" unless $hrp eq 'lnurl';
392 my $bytes = translate_5to8($data5);
393 return $bytes;
394 }
395  
396 sub bolt11_amount {
397 my ($invoice) = @_;
398 croak "invalid bolt11 invoice" unless defined $invoice && $invoice =~ /^ln/i;
399  
400 # The bech32 separator is the LAST '1' in the string
401 my $last_1 = rindex($invoice, '1');
402 croak "invalid bolt11 invoice" if $last_1 < 0;
403 my $hrp = lc substr($invoice, 0, $last_1);
404  
405 # HRP format: ln + network + [amount + multiplier]
406 # Network: bcrt, bc, tb, etc.
407 my $rest = $hrp;
408 $rest =~ s/^ln//;
409 $rest =~ s/^bcrt// or $rest =~ s/^[a-z]{2}//;
410  
411 return undef if $rest eq '';
412  
413 # Parse amount and multiplier
414 my ($num, $mult) = $rest =~ /^(\d+)([munp]?)$/;
415 return undef unless defined $num;
416  
417 # 1 BTC = 100_000_000_000 millisats
418 my %multipliers = (
419 '' => 100_000_000_000, # BTC
420 'm' => 100_000_000, # milli (10^-3 BTC)
421 'u' => 100_000, # micro (10^-6 BTC)
422 'n' => 100, # nano (10^-9 BTC)
423 'p' => 0.1, # pico (10^-12 BTC)
424 );
425  
426 my $msats = $num * $multipliers{$mult};
427 return int($msats);
428 }
429  
430 sub callback_url {
431 my ($base_url, %params) = @_;
432  
433 my @parts;
434 if (defined $params{amount}) {
435 push @parts, amount => $params{amount};
436 }
437 if (defined $params{nostr}) {
438 my $event = $params{nostr};
439 my $json = JSON->new->utf8->canonical->encode($event->to_hash);
440 push @parts, nostr => $json;
441 }
442 if (defined $params{lnurl}) {
443 push @parts, lnurl => $params{lnurl};
444 }
445  
446 return append_query_params($base_url, @parts);
447 }
448  
449 sub calculate_splits {
450 my (@tags) = @_;
451 return () unless @tags;
452  
453 # Check if any tag has a weight (4th element)
454 my $has_any_weight = grep { defined $_->[3] } @tags;
455  
456 my @splits;
457 my $total_weight = 0;
458  
459 if (!$has_any_weight) {
460 # No weights at all: equal split
461 my $pct = 100.0 / scalar @tags;
462 for my $tag (@tags) {
463 push @splits, {
464 pubkey => $tag->[1],
465 relay => $tag->[2],
466 percentage => $pct,
467 };
468 }
469 return @splits;
470 }
471  
472 # Partial or full weights
473 for my $tag (@tags) {
474 my $weight = defined $tag->[3] ? $tag->[3] + 0 : 0;
475 $total_weight += $weight;
476 }
477  
478 for my $tag (@tags) {
479 my $weight = defined $tag->[3] ? $tag->[3] + 0 : 0;
480 my $pct = $total_weight > 0 ? ($weight / $total_weight) * 100.0 : 0;
481 push @splits, {
482 pubkey => $tag->[1],
483 relay => $tag->[2],
484 percentage => $pct,
485 };
486 }
487  
488 return @splits;
489 }
490  
491 1;
492  
493 __END__
« WalletConnect.pm ↑ Summary HttpAuth.pm »