| 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__ | ||