| 1 | package Net::Nostr::WalletConnect; | ||
| 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(parse_uri_query validate_relay_url); |
|
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 URI (); | ||
| 12 | |||
| 13 | my $HEX64 = qr/\A[0-9a-f]{64}\z/; | ||
| 14 | |||
| 15 | ############################################################################### | ||
| 16 | # URI parsing/generation | ||
| 17 | ############################################################################### | ||
| 18 | |||
| 19 | sub parse_uri { | ||
| 20 | my ($class, $uri) = @_; | ||
| 21 | my ($wallet_pubkey, @query) = parse_uri_query( | ||
| 22 | $uri, | ||
| 23 | label => 'URI', | ||
| 24 | scheme => 'nostr+walletconnect', | ||
| 25 | ); | ||
| 26 | $wallet_pubkey = lc $wallet_pubkey; | ||
| 27 | croak "nostr+walletconnect:// URI wallet_pubkey must be 64-char lowercase hex" | ||
| 28 | unless $wallet_pubkey =~ $HEX64; | ||
| 29 | |||
| 30 | my (@relays, $secret, $lud16); | ||
| 31 | while (@query) { | ||
| 32 | my ($key, $val) = splice @query, 0, 2; | ||
| 33 | if ($key eq 'relay') { push @relays, $val } | ||
| 34 | elsif ($key eq 'secret') { $secret = $val } | ||
| 35 | elsif ($key eq 'lud16') { $lud16 = $val } | ||
| 36 | } | ||
| 37 | |||
| 38 | croak "URI must contain at least one relay parameter" unless @relays; | ||
| 39 | @relays = map { validate_relay_url($_, label => 'relay URL') } @relays; | ||
| 40 | croak "URI must contain a secret parameter" unless defined $secret; | ||
| 41 | croak "secret must be 64-char lowercase hex" unless $secret =~ $HEX64; | ||
| 42 | |||
| 43 | return Net::Nostr::WalletConnect::Connection->new( | ||
| 44 | wallet_pubkey => $wallet_pubkey, | ||
| 45 | relays => \@relays, | ||
| 46 | secret => $secret, | ||
| 47 | lud16 => $lud16, | ||
| 48 | ); | ||
| 49 | } | ||
| 50 | |||
| 51 | sub create_uri { | ||
| 52 | my $class = shift; | ||
| 53 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 54 | croak "wallet_pubkey is required" unless defined $args{wallet_pubkey}; | ||
| 55 | croak "relay is required" unless defined $args{relay}; | ||
| 56 | croak "secret is required" unless defined $args{secret}; | ||
| 57 | croak "wallet_pubkey must be 64-char lowercase hex" unless $args{wallet_pubkey} =~ $HEX64; | ||
| 58 | croak "secret must be 64-char lowercase hex" unless $args{secret} =~ $HEX64; | ||
| 59 | |||
| 60 | my @relays = ref $args{relay} eq 'ARRAY' ? @{$args{relay}} : ($args{relay}); | ||
| 61 | croak "relay is required" unless @relays; | ||
| 62 | @relays = map { validate_relay_url($_, label => 'relay URL') } @relays; | ||
| 63 | |||
| 64 | my $uri = URI->new("nostr+walletconnect://$args{wallet_pubkey}"); | ||
| 65 | my @params; | ||
| 66 | for my $r (@relays) { | ||
| 67 | push @params, relay => $r; | ||
| 68 | } | ||
| 69 | push @params, secret => $args{secret}; | ||
| 70 | push @params, lud16 => $args{lud16} if defined $args{lud16}; | ||
| 71 | |||
| 72 | $uri->query_form(@params); | ||
| 73 | return $uri->as_string; | ||
| 74 | } | ||
| 75 | |||
| 76 | ############################################################################### | ||
| 77 | # Info event (kind 13194) | ||
| 78 | ############################################################################### | ||
| 79 | |||
| 80 | sub _validate_tokens { | ||
| 81 | my ($field, $values) = @_; | ||
| 82 | croak "$field must be an array of non-empty tokens" | ||
| 83 | unless ref($values) eq 'ARRAY'; | ||
| 84 | for my $value (@$values) { | ||
| 85 | croak "$field must contain non-empty tokens without whitespace" | ||
| 86 | unless defined($value) && !ref($value) && $value =~ /\A[^\s\x00-\x1f\x7f]+\z/; | ||
| 87 | } | ||
| 88 | } | ||
| 89 | |||
| 90 | sub info_event { | ||
| 91 | my $class = shift; | ||
| 92 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 93 | my %known = map { $_ => 1 } qw(pubkey capabilities encryption notifications extensions); | ||
| 94 | my @unknown = grep { !$known{$_} } keys %args; | ||
| 95 | croak 'unknown argument(s): ' . join(', ', sort @unknown) if @unknown; | ||
| 96 | for my $field (qw(capabilities encryption notifications extensions)) { | ||
| 97 | _validate_tokens($field, $args{$field}) if exists $args{$field}; | ||
| 98 | } | ||
| 99 | my @tags; | ||
| 100 | |||
| 101 | if (exists $args{encryption}) { | ||
| 102 | push @tags, ['encryption', join(' ', @{$args{encryption}})]; | ||
| 103 | } | ||
| 104 | if ($args{notifications} && @{$args{notifications}}) { | ||
| 105 | push @tags, ['notifications', join(' ', @{$args{notifications}})]; | ||
| 106 | } | ||
| 107 | if (exists $args{extensions}) { | ||
| 108 | push @tags, ['extensions', join(' ', @{$args{extensions}})]; | ||
| 109 | } | ||
| 110 | |||
| 111 | return Net::Nostr::Event->new( | ||
| 112 | kind => 13194, | ||
| 113 | pubkey => $args{pubkey}, | ||
| 114 | content => join(' ', @{$args{capabilities} // []}), | ||
| 115 | tags => \@tags, | ||
| 116 | ); | ||
| 117 | } | ||
| 118 | |||
| 119 | sub parse_info { | ||
| 120 | my ($class, $event) = @_; | ||
| 121 | croak "info event MUST be kind 13194" unless $event->kind == 13194; | ||
| 122 | |||
| 123 | my @capabilities = split / /, $event->content, -1; | ||
| 124 | @capabilities = () unless length $event->content; | ||
| 125 | my (@encryption, @notification_types, @extensions); | ||
| 126 | my %seen; | ||
| 127 | |||
| 128 | for my $tag (@{$event->tags}) { | ||
| 129 | next unless $tag->[0] =~ /\A(?:encryption|notifications|extensions)\z/; | ||
| 130 | croak "$tag->[0] tag must have one value and occur only once" | ||
| 131 | unless @$tag == 2 && !$seen{$tag->[0]}++; | ||
| 132 | if ($tag->[0] eq 'encryption') { | ||
| 133 | @encryption = length($tag->[1]) ? split(/ /, $tag->[1], -1) : (); | ||
| 134 | } elsif ($tag->[0] eq 'notifications') { | ||
| 135 | @notification_types = length($tag->[1]) ? split(/ /, $tag->[1], -1) : (); | ||
| 136 | } elsif ($tag->[0] eq 'extensions') { | ||
| 137 | @extensions = length($tag->[1]) ? split(/ /, $tag->[1], -1) : (); | ||
| 138 | } | ||
| 139 | } | ||
| 140 | |||
| 141 | # Absence of encryption tag implies nip04 | ||
| 142 | @encryption = ('nip04') unless $seen{encryption}; | ||
| 143 | |||
| 144 | return Net::Nostr::WalletConnect::Info->new( | ||
| 145 | capabilities => \@capabilities, | ||
| 146 | encryption => \@encryption, | ||
| 147 | notification_types => \@notification_types, | ||
| 148 | extensions => \@extensions, | ||
| 149 | ); | ||
| 150 | } | ||
| 151 | |||
| 152 | ############################################################################### | ||
| 153 | # Request payload | ||
| 154 | ############################################################################### | ||
| 155 | |||
| 156 | sub request { | ||
| 157 | my $class = shift; | ||
| 158 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 159 | croak "request requires 'method'" unless defined $args{method}; | ||
| 160 | croak "request requires 'params'" unless defined $args{params}; | ||
| 161 | |||
| 162 | return JSON->new->utf8->canonical->encode({ | ||
| 163 | method => $args{method}, | ||
| 164 | params => $args{params}, | ||
| 165 | }); | ||
| 166 | } | ||
| 167 | |||
| 168 | ############################################################################### | ||
| 169 | # Request event (kind 23194) | ||
| 170 | ############################################################################### | ||
| 171 | |||
| 172 | sub request_event { | ||
| 173 | my $class = shift; | ||
| 174 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 175 | croak "request_event requires 'method'" unless defined $args{method}; | ||
| 176 | croak "request_event requires 'params'" unless defined $args{params}; | ||
| 177 | croak "request_event requires 'wallet_pubkey'" unless defined $args{wallet_pubkey}; | ||
| 178 | |||
| 179 | my $content = $class->request(method => $args{method}, params => $args{params}); | ||
| 180 | |||
| 181 | my @tags; | ||
| 182 | push @tags, ['p', $args{wallet_pubkey}]; | ||
| 183 | push @tags, ['encryption', $args{encryption}] if defined $args{encryption}; | ||
| 184 | push @tags, ['expiration', '' . $args{expiration}] if defined $args{expiration}; | ||
| 185 | |||
| 186 | croak "request_event requires 'pubkey'" unless defined $args{pubkey}; | ||
| 187 | croak "pubkey must be 64-char lowercase hex" unless $args{pubkey} =~ $HEX64; | ||
| 188 | |||
| 189 | return Net::Nostr::Event->new( | ||
| 190 | kind => 23194, | ||
| 191 | pubkey => $args{pubkey}, | ||
| 192 | content => $content, | ||
| 193 | tags => \@tags, | ||
| 194 | ); | ||
| 195 | } | ||
| 196 | |||
| 197 | ############################################################################### | ||
| 198 | # Response payload | ||
| 199 | ############################################################################### | ||
| 200 | |||
| 201 | sub parse_response { | ||
| 202 | my ($class, $json) = @_; | ||
| 203 | my $data = JSON->new->utf8->decode($json); | ||
| 204 | |||
| 205 | return Net::Nostr::WalletConnect::Response->new( | ||
| 206 | result_type => $data->{result_type}, | ||
| 207 | error => $data->{error}, | ||
| 208 | result => $data->{result}, | ||
| 209 | ); | ||
| 210 | } | ||
| 211 | |||
| 212 | ############################################################################### | ||
| 213 | # Response event (kind 23195) | ||
| 214 | ############################################################################### | ||
| 215 | |||
| 216 | sub response_event { | ||
| 217 | my $class = shift; | ||
| 218 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 219 | |||
| 220 | my $content = JSON->new->utf8->canonical->encode({ | ||
| 221 | result_type => $args{result_type}, | ||
| 222 | error => $args{error}, | ||
| 223 | result => $args{result}, | ||
| 224 | }); | ||
| 225 | |||
| 226 | my @tags; | ||
| 227 | push @tags, ['p', $args{client_pubkey}] if defined $args{client_pubkey}; | ||
| 228 | push @tags, ['e', $args{request_id}] if defined $args{request_id}; | ||
| 229 | |||
| 230 | croak "response_event requires 'pubkey'" unless defined $args{pubkey}; | ||
| 231 | croak "pubkey must be 64-char lowercase hex" unless $args{pubkey} =~ $HEX64; | ||
| 232 | |||
| 233 | return Net::Nostr::Event->new( | ||
| 234 | kind => 23195, | ||
| 235 | pubkey => $args{pubkey}, | ||
| 236 | content => $content, | ||
| 237 | tags => \@tags, | ||
| 238 | ); | ||
| 239 | } | ||
| 240 | |||
| 241 | ############################################################################### | ||
| 242 | # Notification payload | ||
| 243 | ############################################################################### | ||
| 244 | |||
| 245 | sub parse_notification { | ||
| 246 | my ($class, $json) = @_; | ||
| 247 | my $data = JSON->new->utf8->decode($json); | ||
| 248 | |||
| 249 | return Net::Nostr::WalletConnect::Notification->new( | ||
| 250 | notification_type => $data->{notification_type}, | ||
| 251 | notification => $data->{notification}, | ||
| 252 | ); | ||
| 253 | } | ||
| 254 | |||
| 255 | ############################################################################### | ||
| 256 | # Notification event (kind 23197) | ||
| 257 | ############################################################################### | ||
| 258 | |||
| 259 | sub notification_event { | ||
| 260 | my $class = shift; | ||
| 261 | my %args = Net::Nostr::_ConstructorArgs::normalize(@_); | ||
| 262 | |||
| 263 | my $content = JSON->new->utf8->canonical->encode({ | ||
| 264 | notification_type => $args{notification_type}, | ||
| 265 | notification => $args{notification}, | ||
| 266 | }); | ||
| 267 | |||
| 268 | my @tags; | ||
| 269 | push @tags, ['p', $args{client_pubkey}] if defined $args{client_pubkey}; | ||
| 270 | |||
| 271 | # Kind 23196 for NIP-04 backwards compatibility, 23197 for NIP-44 | ||
| 272 | my $kind = (defined $args{encryption} && $args{encryption} eq 'nip04') ? 23196 : 23197; | ||
| 273 | |||
| 274 | croak "notification_event requires 'pubkey'" unless defined $args{pubkey}; | ||
| 275 | croak "pubkey must be 64-char lowercase hex" unless $args{pubkey} =~ $HEX64; | ||
| 276 | |||
| 277 | return Net::Nostr::Event->new( | ||
| 278 | kind => $kind, | ||
| 279 | pubkey => $args{pubkey}, | ||
| 280 | content => $content, | ||
| 281 | tags => \@tags, | ||
| 282 | ); | ||
| 283 | } | ||
| 284 | |||
| 285 | ############################################################################### | ||
| 286 | # Metadata validation | ||
| 287 | ############################################################################### | ||
| 288 | |||
| 289 | sub validate_metadata { | ||
| 290 | my ($class, $metadata) = @_; | ||
| 291 | my $json = JSON->new->utf8->canonical->encode($metadata); | ||
| 292 | croak "metadata MUST be no more than 4096 characters (got " . length($json) . ")" | ||
| 293 | if length($json) > 4096; | ||
| 294 | return 1; | ||
| 295 | } | ||
| 296 | |||
| 297 | ############################################################################### | ||
| 298 | # Event validation | ||
| 299 | ############################################################################### | ||
| 300 | |||
| 301 | sub validate_request { | ||
| 302 | my ($class, $event) = @_; | ||
| 303 | croak "request MUST be kind 23194" unless $event->kind == 23194; | ||
| 304 | |||
| 305 | my $has_p = grep { $_->[0] eq 'p' } @{$event->tags}; | ||
| 306 | croak "request SHOULD include a p tag" unless $has_p; | ||
| 307 | |||
| 308 | return 1; | ||
| 309 | } | ||
| 310 | |||
| 311 | sub validate_response { | ||
| 312 | my ($class, $event) = @_; | ||
| 313 | croak "response MUST be kind 23195" unless $event->kind == 23195; | ||
| 314 | return 1; | ||
| 315 | } | ||
| 316 | |||
| 317 | sub is_expired { | ||
| 318 | my ($class, $event) = @_; | ||
| 319 | for my $tag (@{$event->tags}) { | ||
| 320 | if (@$tag >= 2 && $tag->[0] eq 'expiration') { | ||
| 321 | return time() >= $tag->[1]; | ||
| 322 | } | ||
| 323 | } | ||
| 324 | return 0; | ||
| 325 | } | ||
| 326 | |||
| 327 | ############################################################################### | ||
| 328 | # Inner classes | ||
| 329 | ############################################################################### | ||
| 330 | |||
| 331 | { | ||
| 332 | package Net::Nostr::WalletConnect::Connection; | ||
| 333 | use Carp qw(croak); | ||
| 334 | use Class::Tiny qw(wallet_pubkey secret lud16); | ||
| 335 | sub new { | ||
| 336 | my $class = shift; | ||
| 337 | my $self = bless { Net::Nostr::_ConstructorArgs::normalize(@_) }, $class; | ||
| 338 | my %known; @known{Class::Tiny->get_all_attributes_for($class)} = (); | ||
| 339 | $known{relays} = (); | ||
| 340 | my @unknown = grep { !exists $known{$_} } keys %$self; | ||
| 341 | croak "unknown argument(s): " . join(', ', sort @unknown) if @unknown; | ||
| 342 | $self->{relays} = [@{$self->{relays}}] if ref $self->{relays} eq 'ARRAY'; | ||
| 343 | return $self; | ||
| 344 | } | ||
| 345 | sub relays { | ||
| 346 | my $self = shift; | ||
| 347 | croak "relays is read-only" if @_; | ||
| 348 | return defined $self->{relays} ? [@{$self->{relays}}] : undef; | ||
| 349 | } | ||
| 350 | } | ||
| 351 | |||
| 352 | { | ||
| 353 | package Net::Nostr::WalletConnect::Info; | ||
| 354 | use Carp qw(croak); | ||
| 355 | my @_ARRAY_FIELDS = qw(capabilities encryption notification_types extensions); | ||
| 356 | use Class::Tiny (); | ||
| 357 | sub new { | ||
| 358 | my $class = shift; | ||
| 359 | my $self = bless { Net::Nostr::_ConstructorArgs::normalize(@_) }, $class; | ||
| 360 | my %known = map { $_ => 1 } @_ARRAY_FIELDS; | ||
| 361 | my @unknown = grep { !exists $known{$_} } keys %$self; | ||
| 362 | croak "unknown argument(s): " . join(', ', sort @unknown) if @unknown; | ||
| 363 | for my $f (@_ARRAY_FIELDS) { | ||
| 364 | $self->{$f} = [] unless exists $self->{$f}; | ||
| 365 | Net::Nostr::WalletConnect::_validate_tokens($f, $self->{$f}); | ||
| 366 | $self->{$f} = [@{$self->{$f}}]; | ||
| 367 | } | ||
| 368 | return $self; | ||
| 369 | } | ||
| 370 | for my $f (@_ARRAY_FIELDS) { | ||
| 371 | no strict 'refs'; | ||
| 372 | *$f = sub { | ||
| 373 | my $self = shift; | ||
| 374 | croak "$f is read-only" if @_; | ||
| 375 | return defined $self->{$f} ? [@{$self->{$f}}] : undef; | ||
| 376 | }; | ||
| 377 | } | ||
| 378 | |||
| 379 | sub supports_capability { | ||
| 380 | my ($self, $cap) = @_; | ||
| 381 | return scalar grep { $_ eq $cap } @{$self->{capabilities}}; | ||
| 382 | } | ||
| 383 | |||
| 384 | sub supports_extension { | ||
| 385 | my ($self, $extension) = @_; | ||
| 386 | return scalar grep { $_ eq $extension } @{$self->{extensions}}; | ||
| 387 | } | ||
| 388 | |||
| 389 | sub supports_encryption { | ||
| 390 | my ($self, $enc) = @_; | ||
| 391 | return scalar grep { $_ eq $enc } @{$self->{encryption}}; | ||
| 392 | } | ||
| 393 | |||
| 394 | sub preferred_encryption { | ||
| 395 | my ($self) = @_; | ||
| 396 | return 'nip44_v2' if $self->supports_encryption('nip44_v2'); | ||
| 397 | return $self->{encryption}[0]; | ||
| 398 | } | ||
| 399 | } | ||
| 400 | |||
| 401 | { | ||
| 402 | package Net::Nostr::WalletConnect::Response; | ||
| 403 | use Carp qw(croak); | ||
| 404 | use Class::Tiny qw(result_type error result); | ||
| 405 | sub new { | ||
| 406 | my $class = shift; | ||
| 407 | my $self = bless { Net::Nostr::_ConstructorArgs::normalize(@_) }, $class; | ||
| 408 | my %known; @known{Class::Tiny->get_all_attributes_for($class)} = (); | ||
| 409 | my @unknown = grep { !exists $known{$_} } keys %$self; | ||
| 410 | croak "unknown argument(s): " . join(', ', sort @unknown) if @unknown; | ||
| 411 | croak "result_type is required" unless defined $self->{result_type}; | ||
| 412 | return $self; | ||
| 413 | } | ||
| 414 | |||
| 415 | sub is_error { | ||
| 416 | my ($self) = @_; | ||
| 417 | return defined $self->error && ref $self->error eq 'HASH'; | ||
| 418 | } | ||
| 419 | |||
| 420 | sub error_code { | ||
| 421 | my ($self) = @_; | ||
| 422 | return $self->is_error ? $self->error->{code} : undef; | ||
| 423 | } | ||
| 424 | |||
| 425 | sub error_message { | ||
| 426 | my ($self) = @_; | ||
| 427 | return $self->is_error ? $self->error->{message} : undef; | ||
| 428 | } | ||
| 429 | } | ||
| 430 | |||
| 431 | { | ||
| 432 | package Net::Nostr::WalletConnect::Notification; | ||
| 433 | use Carp qw(croak); | ||
| 434 | use Class::Tiny qw(notification_type notification); | ||
| 435 | sub new { | ||
| 436 | my $class = shift; | ||
| 437 | my $self = bless { Net::Nostr::_ConstructorArgs::normalize(@_) }, $class; | ||
| 438 | my %known; @known{Class::Tiny->get_all_attributes_for($class)} = (); | ||
| 439 | my @unknown = grep { !exists $known{$_} } keys %$self; | ||
| 440 | croak "unknown argument(s): " . join(', ', sort @unknown) if @unknown; | ||
| 441 | croak "notification_type is required" unless defined $self->{notification_type}; | ||
| 442 | croak "notification is required" unless defined $self->{notification}; | ||
| 443 | return $self; | ||
| 444 | } | ||
| 445 | } | ||
| 446 | |||
| 447 | 1; | ||
| 448 | |||
| 449 | __END__ | ||