From 79290a511642f63a2755cb95dcde611a4130b061 Mon Sep 17 00:00:00 2001 From: Hector Palencia Date: Tue, 13 Aug 2024 22:08:20 -0400 Subject: [PATCH 1/4] add new wallet (arepa wallet) --- package.json | 1 + packages/arepa-wallet/.babelrc | 10 + packages/arepa-wallet/.eslintrc.json | 18 ++ packages/arepa-wallet/README.md | 65 +++++ .../arepa-wallet/assets/arepa-wallet-icon.png | Bin 0 -> 29999 bytes packages/arepa-wallet/jest.config.js | 14 + packages/arepa-wallet/jest.config.ts | 16 ++ packages/arepa-wallet/package.json | 27 ++ packages/arepa-wallet/project.json | 56 ++++ packages/arepa-wallet/src/index.ts | 2 + .../arepa-wallet/src/lib/arepa-wallet.spec.ts | 121 ++++++++ packages/arepa-wallet/src/lib/arepa-wallet.ts | 271 ++++++++++++++++++ packages/arepa-wallet/src/lib/icon.ts | 1 + packages/arepa-wallet/tsconfig.json | 19 ++ packages/arepa-wallet/tsconfig.lib.json | 10 + packages/arepa-wallet/tsconfig.spec.json | 9 + tsconfig.base.json | 3 + 17 files changed, 643 insertions(+) create mode 100644 packages/arepa-wallet/.babelrc create mode 100644 packages/arepa-wallet/.eslintrc.json create mode 100644 packages/arepa-wallet/README.md create mode 100644 packages/arepa-wallet/assets/arepa-wallet-icon.png create mode 100644 packages/arepa-wallet/jest.config.js create mode 100644 packages/arepa-wallet/jest.config.ts create mode 100644 packages/arepa-wallet/package.json create mode 100644 packages/arepa-wallet/project.json create mode 100644 packages/arepa-wallet/src/index.ts create mode 100644 packages/arepa-wallet/src/lib/arepa-wallet.spec.ts create mode 100644 packages/arepa-wallet/src/lib/arepa-wallet.ts create mode 100644 packages/arepa-wallet/src/lib/icon.ts create mode 100644 packages/arepa-wallet/tsconfig.json create mode 100644 packages/arepa-wallet/tsconfig.lib.json create mode 100644 packages/arepa-wallet/tsconfig.spec.json diff --git a/package.json b/package.json index bda89d9ce..f70756a51 100644 --- a/package.json +++ b/package.json @@ -44,6 +44,7 @@ "scripts": { "build:account-export": "nx run-many --target=build --projects=account-export --configuration=production", "build:all": "nx run-many --target=build --all --exclude=react,angular --configuration=production && node ./scripts/update-package-json.js", + "build:arepa-wallet": "nx run-many --target=build --projects=arepa-wallet --configuration=production", "build:bitget-wallet": "nx run-many --target=build --projects=bitget-wallet --configuration=production", "build:core": "nx run-many --target=build --projects=core --configuration=production", "build:here-wallet": "nx run-many --target=build --projects=here-wallet --configuration=production", diff --git a/packages/arepa-wallet/.babelrc b/packages/arepa-wallet/.babelrc new file mode 100644 index 000000000..b63f0528f --- /dev/null +++ b/packages/arepa-wallet/.babelrc @@ -0,0 +1,10 @@ +{ + "presets": [ + [ + "@nrwl/js/babel", + { + "useBuiltIns": "usage" + } + ] + ] +} diff --git a/packages/arepa-wallet/.eslintrc.json b/packages/arepa-wallet/.eslintrc.json new file mode 100644 index 000000000..9d9c0db55 --- /dev/null +++ b/packages/arepa-wallet/.eslintrc.json @@ -0,0 +1,18 @@ +{ + "extends": ["../../.eslintrc.json"], + "ignorePatterns": ["!**/*"], + "overrides": [ + { + "files": ["*.ts", "*.tsx", "*.js", "*.jsx"], + "rules": {} + }, + { + "files": ["*.ts", "*.tsx"], + "rules": {} + }, + { + "files": ["*.js", "*.jsx"], + "rules": {} + } + ] +} diff --git a/packages/arepa-wallet/README.md b/packages/arepa-wallet/README.md new file mode 100644 index 000000000..620398a03 --- /dev/null +++ b/packages/arepa-wallet/README.md @@ -0,0 +1,65 @@ +# @near-wallet-selector/my-near-wallet + +This is the [Arepa Wallet](https://mi.arepa.digital/) package for NEAR Wallet Selector. + +## Installation and Usage + +The easiest way to use this package is to install it from the NPM registry, this package requires `near-api-js` v1.0.0 or above: + +```bash +# Using Yarn +yarn add near-api-js + +# Using NPM. +npm install near-api-js +``` +```bash +# Using Yarn +yarn add @near-wallet-selector/arepa-wallet + +# Using NPM. +npm install @near-wallet-selector/arepa-wallet +``` + +Then use it in your dApp: + +```ts +import { setupWalletSelector } from "@near-wallet-selector/core"; +import { setupArepaWallet } from "@near-wallet-selector/arepa-wallet"; + +// My NEAR Wallet for Wallet Selector can be setup without any params or it can take few optional params, see options below. +const arepaWallet = setupArepaWallet({ + walletUrl: "https://develop.globaldv.tech/wallet-arepa/", + iconUrl: "https://" // optional +}); + +const selector = await setupWalletSelector({ + network: "testnet", + modules: [arepaWallet], +}); +``` + +## Options + +- `walletUrl` (`string?`): Wallet URL used to redirect when signing transactions. This parameter is required for custom network configuration. +- `iconUrl`: (`string?`): Image URL for the icon shown in the modal. This can also be a relative path or base64 encoded image. Defaults to `./assets/arepa-wallet-icon.png`. +- `deprecated`: (`boolean?`): Deprecated is optional. Default is `false`. +- `successUrl`: (`string?`): SuccessUrl is optional. Default is `''` (empty string). +- `failureUrl`: (`string?`): FailureUrl is optional. Default is `''` (empty string). + +## Assets + +Assets such as icons can be found in the `/assets` directory of the package. Below is an example using Webpack: + +```ts +import { setupMyNearWallet } from "@near-wallet-selector/arepa-wallet"; +import arepaWalletIconUrl from "@near-wallet-selector/arepa-wallet/assets/arepa-wallet-icon.png"; + +const arepaWallet = setupArepaWallet({ + iconUrl: arepaWalletIconUrl +}); +``` + +## License + +This repository is distributed under the terms of both the MIT license and the Apache License (Version 2.0). diff --git a/packages/arepa-wallet/assets/arepa-wallet-icon.png b/packages/arepa-wallet/assets/arepa-wallet-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..20705413c3104cd2c37af7b563342f55a50da5ff GIT binary patch literal 29999 zcmcdy^-~;8v|V6<#TR#2T!Xt?aCedr+&yT5EwH#-aJN9vV8PwpHE4pnJCE;Gy?^0N z)lALw4>MEMeeXT@oYUdzs&W{pB&YxY07F4uMiT&lLwGv{K}c^SNgVIrt^lB`l!7+s z?eGDahrK;wCRtzF&86<`==csJ3LULFfQqV+R_=Dx zExo#hTewA2{Gp<_rMaY~ta!a-O?yrP3V?$Lg20gf_nRm*^->nFv3-}u-h?=oZ-2IH zkKe%d$NAC*4Wq)YI_}rkb9TvjLJ>3Omb}UGW7Jf| zXhVs31#s|l0A>J;PJSj=DninDvzeL+CsQ322Sx>Vq6hoT=msj*MOgfSU13FV{DJrb z^457}h`#$Ry8TgsPFPAV8ay5dj#wEzY;NpFuKL(4mth8V*W;ehO#&(!kONSN%DQK;NS>N!QE z2EE3v2=Sqk)Nasy-}y7W_}q@ZpIfIGdES>LdZrN9F@z*|IN~HC^stl+4gP{kmzabL zh{BUjS1VLf1sxX74Jy8#v7kXXd?=y?qLsQ5cY;$JsyFz%4qgi;Zok*ZD9*cy??o$`h7Z3>3W|M4CRuq5Zirg+Ox*=#v&e3{Z}3S8|q> z0!dKN_ju6(Ju*2Ni79c;o!mD(FIlXrij$py^nFASND#GY52E$P+5rNb*k|SsvM^Zy zJfsR*vu@cAixcyF!VT0xzNPaSH;bd4q({n5QWPm9j&@@GR4>HA5CMatqoRL~iHJ4- zQxg8S5qO3VNKD;~Sz0OSUFyE$lzMzkyrx_ z8sq&pp-C9J>@-`Kc+LQ#e`(D;5SX$%i5OMkxCs>M2zr__ezscqz}G?YmnVu0jyMW% zJd#n2dA6Yt*!P7%g!DUcoZlpx5@`RAiz=uA!AurZs=^2Orc~2f(Oka6-?CcU&SHiL ze@6`o66u02K4l%;%LY!E1)Ei<=iauuNQ3rWkGluZrKA9V$R3L022QvD~2rF9irn>r{?Y=Kz{O z1N^8D%!3_^CQEJhEQ>!6*~Y>6005~UY;;{Dht06EhD!ahjW2*X<5^UxEO-*YEK~y} z>ksD2n+1T`l2yWbFF ziPjpj_{ohVX2UWY6H(4cqFUN1kvM%o(T;>V4HSgurjJ3%L{+#fA|)m7fP0OzEg5iz z;Vn{q{>-Yfnui@1fF&mK^NWlAbZpqYopPADM=E|6IF%R$UP$7KE&f|H)mj{@o~Mm3 zWz4|S%Wa2HV+g(H7byhY`j#sOoD^>cro=?ZP-`5#& zcJPZ>8{hgSGuyOirK(Yh7Jt}WZ6lI?JS~CHHkl>D@zb<6wO<@UKIf%cCH_MpHHZ>b zlQIU#a9aBOkm%sl-tynQ#&|KKj(sZV`|rP}gzsGoFXPoOIKagScwDgrDPRC2+>1A8 zxzCky^@5N&H`XHGB$O^FR<&wXxNuuG?+(&nfkv+(FI7#kApmz8&_^TP{LSZt-1qck z5bHC&$aK`1$c~&kK8rGk+b>P6w{B$q!gp! zjZ=)ybZ*&Q45F8+v=qUv@IsP(R)mTof)5iez z0C8Cx#L$Ng&KV2g11HKl5vhTF8wBrvmwbpUw|}~iDYcD3TobanFf}Bx3aYE(c17S4 z87QCvjvO2YcP+5l+I85-IdeEJn0G=Kzv=#!cweW?O;4!`^RE$AJUBk`ke+TDGt}DuM$0 zv9do#4E{|^jF}|TW88UP9pC+f7kH_KdgjC|vA%TO)i4jQ>-)*Lg&F~=x1p9fR!!oM z)CSV2lh_w2NMP5fKR5cz)VOC~Hd;RXHsQp(_vX{(#r_NEpN2+Tx)dQyKq`IPZe*MX zCU5b@i-qp_*1AQ?Q87pk8&Hx(|fQ7Q!m~_hz{$%4Fq^ zpY`cvMo=dE@Bu3P^)g>j8_@2-flbRe7@zG)826aTxy z^5{(Pq?EE={aI(*wu`1Z^r<@UtE_aam{$$hjSr!|haUJb@6Zi#OO86a-fFbP;SbD{ zOwEhS+K9rSU+6?{!-hD6+g@q|j=ovxCt2&a64FWC!3QKp@_90GGm73xHGmkIa-RKC z#1g2>Tj*J%gB3us_)^Ug2X9gb~w)IzBY zWW>&RI>*Nrp4^vH3hXss0hMDYp+Yv=tnfer%xO=lD1Rw zyMjI3#Bu7mq<*y@50i1w^T;}XfC4}f#J5;Fjaj_$WD~d{=tAt><#*~!iM_3%1_@oWBSGNB zPtvzvrGqC@zsgO(JRX3IWNX4U%exq9zi}-I%m}0azjmloCKELBGuoSLPo&Y5GANn>pnOeuw+b^p!2$S`?+euL&o83kPIciL+jna0Ikhb~ z=hN4b!p%lUfQg_R9eP~84y`2|v36XG-#+)XE7E5}CJW7%^{Sc273Z}sz)>&bT^oK1kztYHwm4E@{58qS#vn{q_J*WX(H7Qlz z3{8oE%Lt4wdxvn?KqAbW*2ZHa1kpTc;3id^R^pZ6Z3Gu3!+SIwl=D$<23}QmRR_6P zmr`Q4>_}g{;A|6F1Xs-Si7jc!78_%x;QsEpPJjW}xNyS~wjQb6EW`Xjl}aADjlK}t zx#8JTb{`j{>qzd2F!P%xsQt3WQ#m*r$qXkB749KBW6a$6?3>C$tWC4UM!o4AZ)eO~ zoVN_9i78^QBg$q?xS)Ln!<+Gj?!~p8*pcg%o@@^*?};H?nkxEpDFC5!^^QSfextQL z#`zuBa$8CW)F5?6a4vz!duhw_|`gT{x5 zso9KZ;ur*4e+Dk-fYcnE&ukPCz77jHTiaW+Je@I7Z4}El{5l#QAdr(K2ToiD7}R@J zx;THb-qB7L!|$1lvmJ;o5FzyAR|#OWfp*+A>rf?h_!w@8V1FpOX4GE=K<0X3m?sh}1DHyIN7 z7{-fHl3s|7w@j-ZKddlcl@)-VgePWFmxn{acR&0qvV2%#5e!&u5L2myTBti9{gQvR z?_9y~#xy__=eioEmmczad<(dKivOTtB<{x!rZ9@aa+i1JG{9*n_u5PUU$jWwDG`ln z>+bnWmP*SVN_DPJ8wM6I-(h3%Il#8JN+M396T6ZcVyf3$J7qVo@*s$(8lY4hf^8wc z2XkWe$~``(*5PJQEGDkY(sO4G=uora?UW-O%%=jA8vC4Dy{#-pPR58u|PKHo9ZM*>#H`ACkt{ zdDrQxgq_A^HvL-Ntw0nKvax9KAQN2e#PkK+|A~78Z4$!!L?D6x@ui#RVj7%;_q!}l z%;lp55UwBhyJ+m9#QVo3h{%rEcNJ;pBOH&AJl*$7U=t!Ot}xj=C+WEYnY!8@6M42S zHD9mcv@plaRj?6uDiT~jjaVBFLRe#tBD`8t>^)B4fW5JGE<#7U$A$a*iXT}0v&wq{ z9ST&zcoz(+wAwHei3Q zry``%Z!rvyxLeC<{%NQD%VwZgdGX76(vb3jAAssE75U~hYe&+ysHbDVRGI-<25d~d zS$pfaqMa8SLmOzNk@!g~w_;kz7jl(RGpx=kM9cvh7PtWf&=>h4^iac85SYJ=)+H0& zj>sZ{Hu~9a>ssv?kM*ffC3f71y-*|pkjb^z55o7$)Oy_R9r^j&-OFgn-BhK4CSZ8( zYZ_RAXM4qCkm&-q1k}{zJm}*~e(pGuvCB z^-ORe(5Qi04eM6z*jnF@|#|W(CNreMX5pixqEB(kf9!yO4p#Cx4sq3mnbRefGutD z$otZ2Ce3+30Ffv?ALl0(8=1_uX!uK`me{qt3~x5w8vIlD7Qgv3;sSaq6_U&z9LM|C zW#~ug>I`H697@quB0M#yTGXuTnY@bQ9AAFeCz~X&K4Cz0a@mnhwhdJkDQi8)haMq^ z>-K3B;esDaf`f=(xxMIdNos*f0_uWPFK2(~Ak&ca&mV16*Yf1!o+5q{`iK0P z^wem(%(X6`Hw-#umx%POs@PcJ5+Dq)#@|X;AAu{hV%Sju6_VQSQS5XNJ4v$Z^2Oab z!OvM{yIZq2ri8bvf6Br$Cqi0`uU=_e;R{Ce&*IuG z!R}cHSX(ND49PhnQwN3b31f&KKYh(Rz{$PaV7zL7=<(3Y6o`;tp_I7<*qS>F#!tdQ z1Arie-qm7>)5BhNMdGjdJFNp^ARY7a8ytRSrmfo^9g9GmNn+H>W7x{mbw9i2K!g&AWs+=?Zn4j1Ys{N&$-el90yv0e zw*1#vRxX~^a?blPZ$GtqYHqtR?Y{$DOT54&WE7cQ2DgwKTRGAnVM_x8Ow^-_ASCw~1)J#!U0Of#C;9!D-cp~5{7}oLKcmV=5Q7IZX z%5%+L+f0~P6E(R=L%+T>@80C#fz3rySbyY6_l{+*ThtJ@K$PGGWMYBrSNw1jAQbk$ zYqpc8R)r;8CNHgePu9CwN;|N)Kyb z+FxR`fv66XoTtS9{mvxk?`vi-GdVNW zFI;#8^$ok7O3)5P6u+A+AsIf7PmZRh5~|yd#vh`ou$+0wr``KCrGO-6!VgcLD}K#p zHXy8%`HKkir>fedEV2!0knt#SvVpK9MHGH2Gs?+9p`IMi_}-8EYMV7G)~lP3mHUdkwW?mhd=2kAh0JH$##K9paN zXsJXb{^F3pbHo^G>QJN{z;X>&8o|Mtye|hm1&uL_^ySn8gE~cg6eCY%Cx)HGrK*EkQ%1#5ZmR z;&6onyu|l~!GC+U-A-H0L+9dJUjZX)YZj=?UR7dzxSS zq_fsR>WN&9$nyHw==a_ZaMtD?^CVU6RVw?N{a$;!G63^obf> zzMrKzPP|lTx73P5GAr++AII|~N1YWU0oAm5ENPixMN5kKfvJ%=u6c(8=etiOIsaC_ zq>5hqc_TLew?LEY@aP5bjD?>`Ulct;O@hl&qu1O#e~4?9NuuPg1veiDM~_MQUkDIs z&0c@HnUY*9ouA6Z&8D#9!{=Q24v=y*Q*i&pj(cz0W?hyc)=vfWx?qU~ZI$p<$$|28 z4ySLXA$z~=`;n-XFF{81l+gOq9FL>r2}SfZ@1k(($NJ!0y)v^Z^4|rmpC>XKAq#=( z8T?eKi2fh$j328jXa8oYN0qaMlNu){n zcKXAzmOc1u7g#xI6lZmYM;Jj&U>4|{>gdJ%+B*bF_tl3vn*Qc!n)ka!iE0dd#b1xV z(vG#q##`&HxmzU&}wl!r4B}Y1H*c#-$Z==KyCSD{ zzO9;etxY}F$dnZPUx(w=?b2A+B`HYYxglYG4Fgpx?TM$p7xY0`?8_FqhH2+;M~C=- zB|*yhP3Oxhu{+*5Qn_}0VxfUoa#TOY&n4h6H^&(Pm6sQ|n1!G~=seXVw#x47W<52J z)9m6mm+cpzA6<&j>AJYQf9O7jA}przbzhEh*L_`S_msu0DFT+7%y!-4(eQ`^Pz2QZ zKPNk#a3rR$3A;>JMBIN8k5}rE24$h`HmZ%M@LclYmeE|G!rQD-4lk=ZEK|@=GGJJ^ z`w!ky6d)qxd-j!#!}U^jma!GtS`K=-7SAzT$+Mg~r;YViw^!+_qSQPo4PY3FIF>Jq zu~wg(InC#=AWSA|q#ltXCM2XqXE;XNi$IL10np;t504+(Ub;Tf;reS2SC67OQGRevtZ%rOx_3`Tni4oVKsKDYxGaMxqmeNv0N-Xr2U7HgzKi{1kST z-H)1Wt1i(kR#Exfj8N7>ZE zhfIIUJ8amOt7uJ}5N&?GC%wZy$3zIFI-abw_46icbcxA?PIbK6&ieR6A`VpOplNSf z9=qB4lj*oLc?R?fzU-~Iz{M%AkK9sxjh7s-Xn8^=a)0U02>`?PN+ZvzE-D7Cr`-Qh z>{jzQ0$4T`!iKor35L(`9ZQf*yb|r7F7C$c4oQ9re{=f$?MVMxn$7-Clc}0z!EmEL znQu|+KgGbsJ3B4+l_H)9XXf`NJe4cXKyA}D(Px2wtvad>y?Q}$BEClU)`1vz8U z{S{v;vPzL5(8I`MkI{YlA;z07D*-iP?&`CGXKvVO<7i1on2nXC)B~1rpEC|jPs>!7 z49CYI?~u0e!w{?B(rvpR*@Tmo15J&b7}os_%)!^f-}H>{cQ=XwO2F6Qj|}|(X7j&z z6q;XG%pPCR0wtHD2g;fK5;O+>aknGVVJS28{B}?wlw7o5f8qgE9Us)!7{0)ZQ_5U? z(0uW}<;{6ita+rv)g?zTb--_3qM+o=dF7)(p8bHqHAU8y-86jcGSCrrf-fg+K)xI;N1A0S=q`!_62;q59W# zcOKLqYq0bL9A?=#X}bDq19p_l?HS3A4d2`iiZlM6p1(M@x=P08@p_j>43JJL0iv56HHi3}uIzQHH1_1y!%=H8h+8uhJs|UbeFohub z+IV22Gwo>bUG+&)FgW#WAdTOF_1n##2KiS{1G*U-L)(@dK4X?!Yw(UBDywkk1!Y{g z6<~X!Jc>Urip_E;X^3^u-1IGI6Cg!99`8PTOVvCM5Ta4#<`&5V*x;S9fky-AQ+(+l zDZc6?(eZUQ&%606Vxqk38Os!yzEXJ8`Mbl^y=OOt&m>aM%i9OFY&eO@I_~*qc*d%{ ziYjUiCo)6mz2<^&#+In-32jUT$a2{Gduo||teWl+c+DBJ#5DJt{l*xZy8TneNdU{| zZbK*dks*U;E&aB_e_IookN z)n&YGRZd&t1NIx23!RVS5q&o#_8iU|Dq_ua@8 zaBx|fK467vbo|UzT*xzONYU|#tJV%zy7gG|GH%Qq(qGsZQ<0UppH4gkRmkjQ+ni7Y z0WmpWSv|RBLvJVEM+dI1uX}h3;yl}{*i>u#_-?yb=*2K*dEjp~9#H16C$-KjDC}>xz2vlJCnUV29HD0_QRvZ(!bIiFSuxG5m<)P_0pU3|<@V2;*0X=C@nnzZ)!3j3P67p3LvebQj3Mxn zd{>5IR@qwf1(8p9wS{xE1{XHQj0xNFZ`vt@`j*?^kf1e)m*bCb@Lv4X2=9t?H+OQ1ZUla81((8YY{!ET3dRW+^G7 z{2L+rbu65@3NM(DZPkk*W#t>j5Yr+B46|(4T$HDGcKX=gefOCdYFiNPc`n%>kczlBRWguG1|D+Na> z#)bP69}_@cq41y*TGITKx*vZAuD% zM$<|0p#pzHCkCqBTcdbjz$^d5h#zhd6na<`lfyRIX(1|XIn4iJ!)p1A3!D6jxR-zu zX{Jk68AcX~zOqoyyGaF`Og|A?C!D!kDMvLLJYv0~gS}9oKZ~x*Mq%=-kW#AcCsx~` z$Aq&fD(LnbB37W}0?*0!-InVTxgtFhgk*a!Q4Ml@INU$%9x9qlvNr<6fN%nGmeBTx zq2l4wXnKs)f=PZSCZnNT(WeWtjWdJaF(qFhz2BSj0&Y>KnQ)0L3PsKPU$O?3K|s{~ z^|O}myT}$HkV&#b@4;B`-Epb7Ez`GrY<`+@JX=@G5d#nUmCNIyJ;#VX)b_GURN|_d zgy(D&CAQ;UB`^-_T%ptg10iEXs;1W%=S6oVq5z^=ldNSQ1m3W1a|J&|Y+B@L4_*%2 z#-{Xl5Po}FdwcBVw2JN#HF7XRAiozv(3{OfD(>`XBMR1el;QK2Dkz(heK8ir#Og^< zm)M&-?BarvfJyZ%wEW0lhyv2jQC_4zhefD-NxsH?j5tQBN`_CaI| zRL^ZJwkIZ|sdamjrtyRQGB^8%5^#MxuX0h&aqJFMAOpsa0+cLyYWO>_b&;qwto$2o ziCvUJ0vr}YY-1LGO=`Xx==@3%j^9vsh+^NlpU~_m}TuNX4GnHQOPb@ zA&kvm{ax9r-d**;vyl*TP4xR%jb0na>?{1TP2qz5^Bzxq8t5Y&2%L_C!<}m0W?bt{ z1b8c+#&S7=7kgv|mGdUWhc@VzeX4lq)jpM(JSdi9^{A$(Lxcc2Dg$zqPR_i^yf^w; z9&$W8{2&Ij%dj3>{kRZ4BovC@36cKsY3WP08HBMr$#m96huf`zz{s6}^4^M}I4ixE ztHwSmB~Hy$wfxbtsCv#Hcte`TZ3q5-lUvh`SG|~F;1gg#22V%8{R0kNbN>G9vEoT8 zlSzfDLQ>z~NhM?XHAC}i$*XVc;zSpz9>Fq`5%-8BQ1Y>|Wf0fznIuzX@ugIh_VQ5jdd%KUtELVq&SCJ6+Eh4A8tpy&Mf(u!l{xE~JYulx zL9}DmgEi3WOfPIf4S%;I1dvBha5>lS2r^qWqcb&b%_5juh2?g(G}B1MkXMAJbTeI# zv;2M&MKQT!mo)eAg7d;!p5)?=fK>RlSHtP$S^{!`K)n;JT#yJWwINT-=sTVK-v6*e@LTU?kiaUfQg{yxBFIS7S#h2*x|FuiL42 zX!h=2yonKM*OI!x(mN&638wW%b)Ef1T@O&_<3CK-ZVQ$S5+KXHV%`DQr>AozE&4{c z?|+1e2_O<&boR;+p>1kW1h@5jXA#CX$T*C$U+|nFD|^hpLxS$vy+9Z3;8!l#j}*Dk_iG9PEM7#~>G z#6|A=9{#mSo2IpuTg9FE{ghZedy9uSD5WGM1u0%!lCeLI=j^!2^ZKO$_=hLYd6cFc{WasSs(hZPMy5+fHjD!kD;w=BUu&-N?!9!|e1BTzzm6SV{P8`UTcxvTh#*9Xxr zeFqzIntra&f=yj6W*7co#u~wVsj&rl!$yH{#bOEqU)S11Z)4plRkXp8DZaJnTwwU1 z!(*|!*?x8TBdc+4=YQCRd~eN5oQ76pten<;yp-Z9V%&w8Pg?8ZO(>2r6#ackh$%07 zxp>=V?Uab+rVHM~cUN01oxOX1^#gfJ$#$9#wr^Uk(r^i&C(hL3+b4Hx0it^ZZNYYmFR8+d*R#mU z?uT$k2cuC1Za3)+X5&lmfq+r(pr~EdKl+bbHdd4Vde&R@AvZDeg_N*@FrU_X4_g68 zAIoieAzWJV9`rw-aB<|>J8eT>pUDQo)|i7ap3LRUc(OZ9sa?a1W|`%B)pw9m1G)sx z)-1d0zV-jL4YV|(T#3)yvp0Jnl&3TsFu2(rG~h>)2Gc?rOv%K28-+ivpw1kSBe&t} z8znlJKqw45;s5S0DOQLH}mB&DiJ|Y07}KrwatNxN^ujIjflpv=j#4krvKQq0CZd{TPi92FElVgOPC%kd#| z>z21d{+Qeui}UN*C9_YGVP|hl(AuhZ3nf~2D2;UE(Lv?k5J~D8$!shtMwNBsPA9k) z1Z*B|UyqBFQF|_HSZx1Rg+kgS?tXJ*n%L+7aq>;bqu0-wb($jeKGa&g8Th_BD87ef zFlt|}J#*E?t%~^tU8~@;m9H6B4NEvfM?^Z?P%I0*VVng82x7w=XTh9mp*oYtk5v8# zzT6H`=n*Akbama&@?(Fvs^vOkwf=-M;R#=f+3nX`_bSvdV?6!XRDe@0p#?WFkSM)3 z(A-6+ZqWJ)-|rW3QiBpH4xLKs{gooRyl%=b>a;oHWNke|sc`#-wj3;KC2I_^0f2a* zgb3Ted$apaZixK+YZToW*dwp;9&MD16a_5N%Y;nBJ;`f~)9sxRFlJcH)HQna<)KIg z>*xCFJ-#s`;uZ7c42r^l_7vk(QECS(^v;XM@fxhihV)Q83}d z`VczW@y^i8accY`g`{r6PU@&2)f1^8fyhL)y+%rcQ$Q6)q5D*W)LQIzZWX~R+UTrv zzA&;nB?0|_<^$XS6t1}@2<_N$akw(m86ZO`O-u?&@y1Ws<#FLTsZ?8=^`l9Uv=>2H zf{e3PJY5YUhuDiZXAGd&+?A}PlShk&aJb2IFN0IMd!91&yY(K@l9Aud8L6<`x=EJb z@|`%}5Wj$Bza;5xXd7`M$jnkn^`j_JEHw~!K0^g_$y)t9=F0N|e(Bfa0KohBiXL<5 z!{O%AQ%PAfwLJQH5Bo^>n77hNGEJ#UqW&5WIK(6e_kT)U@VSSZY z&I2v_qM6^)fh1<`x}07se3i*_;VzI}??gL`nk?UFGs#zt$foZ_Z@V07A|I8JseY4% zm2>da=e7K08SABqPO05`Mud|_DyR?TGzU1N6%7ofc)a|h22CV=?lkz`rGP@uNPwU@ z$?w_p(@J?4@^r$I9GSdfw<^UBTme#yGX{?2$)B9!NFzAemsJR6D8>mAL&SSWCgEe* zB3WS)rrgCkfbVI!(&O?BQ_hMh@);Pa$kez9D_9cSlQVR%gRu2=$Hd1o$0-nM^I(}dtcVufJ1&qPVp<|`%ycd6)r$)%K3 zIOCtC#Ei-wsc;H%MD`?s70MhKtouF%=H_Rbmr+PT`za6^GTV1>C^ojBHcpSfgq@Z1 z!WW2{B(MeLGh48HvNtct0(DL}9hIHbj@nq_DCtMjcjzC{dxUlxaWa|?(c4ZF=D5I0 zJAR5+pAjXqrEEaYfVzl1#~@Y4XN;~=I+&CQdG#oe>c`q+Ju3_{87ilE*{y^mWB=pT zgTtdJso73!b*OPjzR&tpXK}tHj$=b(-`5wOg8Gc5r0%uL5EGiVJ$h#mW-H!u*yixw zpSO+FiA?7akvj9A3Uy!*aB!1U{tj|S`iw$`tR?O0xo=f zI((rvN||LSvprUF+DflYVnFz#5AQK&r%_CqAVowhb`n|IyHkN_W@oODHC!zsWe!_v z_+$&9%5NIl29+7&4UrwDMpOqw^E7aTL2FT>U)QR4V=KTds%f(I%j#dI@ZOEKbZV6@ zbSzZW+emncp|jjEZDXzi^nKTg?NSa}3{+JA=ff`BUR?M;+$OV_E~^uG9_i@S<^i3o zB!D+@;FE zTHIBT7fK+2fVKVAX`(U8hL*N-aH@r%%!4m&B98%fq6UHw7lQC=D4=DK7=MxZ`^JS^ z1I)^~#HOP-NZt5TNqH4B@cL#0#R@hzaQYC)C+@7@le5w6%h53 z6S_5o@hsBmsp+{xX|WE_BlAf6BW;6fWiiOXbaxT@tXiFUfS#|7R>aVNc9qkxpC*q{k(7}O|>I!Ol@9V_6Y$eJTCuC6pvDqE}EX}qS&O%2^KAobvA@c-)05P#MHthN% zTFQ50dP+Ff-%5Sb1F{+)^3ga%c-UbN8#MBX$N~&h`X@nPSPVlGaUG!er*=7 z?Zps;EiM=0Fh-`0QjPWEoyVP7Eul-yTpme)ai1NIA@9J+b8DL5z!<2iD$`JdAm$Ko z_F2T9_1H+9;USE8 zSy6d~xx3OJ)zDQLPDd0Oh&&4(^4lzx;AyK-BX z`;l(%<4Cqj$z-}zhu_8-mtj^EAUC=u@`;{>qksJxIqqhL>fp=D@ zV<2RaVNU{OI$uttzJ8<1nv$hljOj}?lF)iXQbvLJG(FDKGlH|NzD);OqjJTOfvO~t zOAEXO4RFM!_@kAOD5@YxG6B^Dy?Up2xgb7{0Tfuzqxa!QRzbU~wp%K;gzYSzLY2_n z(yy+H#@P3y5dq)-Ss#$+dlQ3}R1o^o6d-eY3VBwE%HcDr(w1CFmEuv~`3@KGR<)%>T6RKZ~Cw$pKC<(;j> z+SRRe zPdlJM1`nQO_*Yf}HBhN8x!y4V0H9v{Jd%V=rH>hEx|wyIOo)9seHE5N@$Xm61K+zY zZ?Z|yt;nm)EzCE|^KpOfvd4UtEi4$kBm}!EJxd1lBjIf#hhuO4qct7`~!w0 zYPz(!Z`=(DoOux{2w*HbS}JVL0DPaHd3?w~06rWq)2B|YqU}oBhoeV^E0py$dPnv3 z)65+?&%7_YkmU9b*?V(&r6)zOt!wm?!r0IhLkyz&<`K7wVe@TI8=c_{mxKw24Hb-9 z2kCe3A~F!r3zlGyQi#$oia*wjZHo0)8gyFrG!(+5f( zF8AG)6T@>0`=M0%alY&JuA-Ow#a zr{u9AXA5nV2OagjD(LDER)>H)5T0uEy$9z_025sqntVcly68Sn{+pvshwYvf#BBT1 z&z7;Ng_v_Nj`1%jatQ?Qhb7(#DF#vU4eaI}w;Ozm)T@H#**!dh zV)z*JJraE0)z8dJ2#~r=VmB0#CTRYWUd@E-1Psk4ur1-9B-d0<2>KJhgGV3%uGfnQ zCzoYSi6^D9#>BS3#Ig)8_wr>XsIfh$@ufJzTC@0_mB*DZ33vAw?j9E&JD2nejd2=^ z6dfNE)dnxtlM0e0^T1@`o3W0&x48D(3BwlCzMFN1;mDeOlleBxfRNi8bH5&a^g}I` zL1xQt&mT&>{OlqLZ>zZ}k|C$!3nUZ>x64}K~ z#lZ6cKA->ziwxoA?%*F!JEuv$dSFaWZiM)6lZhwFEtecwT!*7gjlx(eyVL-jjx|ro zTQhx~un#e!LhNN3eVM8 z!fV_=HY1glZEog2iJuW&Eldbka;Xjnk+dTXv1Ko`K85)R2t*7ve14&mw6Jq=9oPS5FS^p%q@tmRRg$(}eWezwwSsp1(8$k*!$>H|l)aFU0=O=cxVWh$k@y->Xm zC6BG$RP#&&6FcOD?UT)}{Czce*&phD4wMeP=`+0G%KI z!0%;Kx||G@%e$Rt6)w-XmxB)%l`QO`u1wO%Fc(*Br%O)=aEXMBI$Q=xL3rgjeRFK~ zS_~V>U*s&$bFSB)pT+yz-HU?NP1}9bHQ1!UG6)K;Q+1f%JFsc=mFO(oA({s?@!&{V zt^M)wi^IHGYB}b2OPK+fC8;xC_flhxR~Ewbaea=Typb7>nA?vDdEZfO{genCRds&R zuw9u~kSUdq9Oz0_79}8J#(n6}3ePId5`P{QYs1fZWl8dh(mzJ{E|dgJg4gd}{l3#s zKT+Pv+NBtf3~ZUG^)-@6M$?tsH*cMFT`{?>Tl>0~v|7I$(`nmomP1B)l1LRW{`WH% zxdG=7e%}BxSSM8V%S8Nq<8fws73U=}*c{hdPd7`{)OcrHSUN%sOH}^ZqN@^NA=Yz1 zpZ=`E)ea_mi>=Z0aZ$_Pl4sxwuW(!e2T`!#-H=u%n8Zl%I;NeM&TfTfY_rl1>yF)I zgRbw3zi!A51kMP~)8Xe6N?>wCbpk`mZRq+@+x}0Z#_#^CmDtfz$R^+Aum+_-z4GsI z-Z#gs)Y>9caxroE(=rXc8!6$HO!4H@7}O4`73pp8Rg<48!UyF$Y*za{$oSUtbIVvM zoubAy0J5iyAWM3V?*e@4krmsp6=)g_{+$M&b0-FzjQqJyBC&R9T}{*k$&%^K{? z+UN@f72`V+STrr!f^Kh|(a)dreiPms|1AH{3$VgOHTt8ff}z!9gI1|JTFaGhnmTnhBB<|D5XMFSxIvcFNsv@>ariXuf6(HW80|CWZsUn|y9vC+0S(<~ zS`a^bgukmlD}TGsD-7$yW8$Ht; zo3ny20k!n*wYx&j6oM|JA2&Pl50@b#PI2jUdDaIDdV+M90w;fOg>=lhX&(Ll4jeQb z3PG<*kQ^<{(!Xieke?Ej3ha3)w$T>{90!TPpWHZ2PXS>@(lQU$%_vZIKb}v|o~-E( zY@qeO1sI#2T_@QIY6|BLELNL4W8rry^6Z!R@TG4I+F|DtikPCCm|QHK2Wu49TI!zy zQ1(?FH@(|z`KgK@Bj%L9%YKX>qYWBR@KGbNV8E0xdfwWLCwP%JfWdr&21Lt^bJ%iP zdXxPr!k3AQFCxr8?P$ZFEJ#e=$3XNH9RsyY!PG-Xe?l50X(VEfvT)w)WW70xg)?o~ z_vMg{;o!?ZRH@-+hNk?A_s)m^sSxNQM}1<0{Nm8ZgeqL3;6KQGje8+T_W-~deZF<@ zn~Glb4)ZV1R+%bB&oU*By0LrDb|gJoAI3l54^KNugT z-(!pO;Z*(`ll<2DZ9yaT+-}=*apsZd;{vXLLUOZ2jN)eOK*+TFAX-4uejFV`%b%ye zUz9uB>VT9s-G`s(TC6U|PF_cK!l?~<5jjb;i)WrRufFMoSk~(`qrj+4u?oD?(YJ_` z!s#KntT73cF^YX;bTEl?pC_!Pd;$TSfsaDn^?|CgzO*M;gJPiV#gCpU6QwsAWaN|i zBcH5){un<2x<+^%v zboJbaZ;#9oqgQ{u=(@+{`A!tPmQTvdXW!+hC0j;^!%scNWVqzR_%0^Or z@iBk{#U1H4Q}ZK!ANqssRs@!`P^NdC1!<9<^t8n#?)f)hH>2(vK<-|kZ{vlVS>%4* zdwreltieSX;^~zQ5kSI-o&5W3a3Zhx&sn8|Ix~36&<< zsAZC+o77kP#kuZwkPCL-nS_xwWrmx))38{M$5^m!Doi**>))~Li+IZL%9_k&7P8pE zEeppg?j`-?jGjITQWeyzJCC}~|fshiP)@_D97b+x{~F!Bs*lgB0`;RywG z{h(Gt6W#6j5sE$x_GEi5{}NBx-8t z?EPVeo6I?xbT76Gnw0?{y#J|Q%NeBA{uyRbxp0>*`IA;|=n`V8f;XJ>ep{9-4lp93 zM=9Vr{2^cWXR~jA2q7)$I=v}FWxTp4i26jc4kXS*eU2S`7+(#K(Bpp>z3poz&Nk5y zvB`P1@-~Dj3Pq@Lx8)5{vMaYIQHPM|K9B{?vr5G z(0)u+k4mN09?qWq@<%sj{dVH4aRnu*()>GDQ%}^7A_N+mk!Kl>51k3xeyCO{f3+?yjbHBn^Ag3aq`3kJi*PE&J;B44MU$&Rr(ZY;kFlM zOFtk~NAs775J-KJPq0sz&=LiR0h}SzSwrWyv+Lt(4^nESE$m9FH4jzt->^%I_jW!o zsz2VfxX-d(uHRGMeJ=Cb6Q3_!ocy>c$%)cM>W$R)cFYhRzBan;Iyh?XJov3?tP003 znR5)qD802=oBgz5!%`U3k?@X*>5#!6H2y(gc;v)MmQ-iAu>j|#l8js#VC1tPhy6w$+7?g?s-!5?Zz|VNy5_C#v{AcxvC? zU5@AS%5XS2MisdT*e?g;-W}4ckuA>znzpS)g6s)xBy4@2&>Z6mXvh)HtDweg{ha8d z%+TnALabRjs0#}6|K})n^de@cKCIL}P9Q96d3VF2Fb#t!u`?(k7Hhz1uYVSm^B)4l zR6-_W8aZ_S{4j#}6VUoKATv)R2C!2N9zPAg%+?AL=3_vi?H$E6yN>k8GW=ZzlM8>= ztI4Qwg0$JW^{<9@P_55j;BSU^s=q1>*9cA~A~(fpGba^tad{KZqWD zCQSy~kdOB80*Gecr`MU#3K8GL{$^L-WeKxG&XIiPnR(&JYRYwJWaNvZ7F(7d1u%e3 zC6Pn;$Pz9D!h5Yl&NK?lCspZ_BT$6MJO|pnBT@#i!D2=SJ;m1Ki@xeway5Pno;Gtg z5B?&bSs2+VQ8A{qCfws9X$XCDeMlw61XfW_!NhFO(n9XIe(pLN2?5)C33#SKBU{A( z6v2s}fmxZKZLKR9F_eMJp%ty1C!EGaKM&^|`~W6w4nf;2@vNH)|Ex9ioR&I6o^ta|VLw?@0y;c_5t6_|2ZHTb1TZIDY-6;TY4R}sMh!%G0-1ce1d3iC zR1L=GU<)_MoOw)EW(o)WyF^A}QUyl#fdmaW6Kw8$Umg2MQ?%DwX;{;%I1G2X$8>APSvD5Rs;QIhP z{t-4@_>O#yAc!GiLBdf`A{aL`>>i;p-kV60HuuKmhY=qwHSIf$9Aa$F=|eLgRJgqy zdFCr3h?o8d3&?=GiR+JV?aRAEFP`VmU`nn{8c^6;6Uq@pgAg+3WQ&pxl@kA)$&lRk zvB9wK#dKY`tDs}jA%DyWXE6^Xix2Q3(n>IVFwEd$Z)z~f))Ie~=ZK5xwj^SfS?0OE zzNt;4Yu3qb7@PY&DQP^wfP_5~IEe{wcyo<)gKyLIsiQ5LT^~GHpk2hq3WY2Ru>5YJ z*6A069eGmSMgHvb4eEo-G(VPm43Jiz2lQIEZjw7e%+ zDhn!7O-s=K^tv4^<2D$M9#1IvppQU6eTqnS5N>uGfF?A`^EvT=yMMuK5U4?8$W|fkI1>ab=hllDU+EY-Dwm~WrT>n)Z>GDE9doM+<|qGv=>J)4(}VX=O}1h5Hy`$L zp(QSaBzD+eOyamF{n>z6VPxj-=QH55M zKLgNq0eGS;Y264Z|GNZ)Pe|%m>t6V*Qn6~y_uEc5{~-tzg)Da==!#6%lYzN&VngIT zzN4_kWWAe%+T#Q;sfK?`qIp*lk~=#?7`UH)*BD)bgG@ekc_6)mE7syovs+7?s8+y6 z3Ka1Jx?yu%V%s(pMZ#3q%8nLA`7S@7^8H$wYDfxm!N0U}cMS;Jp;1JCyhy%wvfkYh zbm0#y(h+qVeg3?aJj=AP-{o9`qu!GN$)WOFG-hl;^UReV%2lV1fS@lum_igp#wrzz-^{du&E_S82@vOb5GYHLAH75zhBA z3T)b13(^23BStckwHTnd@psGNxOmZu=kwl~Bi3ahKkvwyi#5?|&+O`OY*-^!e{TD;OKpT$d4SFjhnS5p?hx-1Po!Zj&IISPBOC1KGt& ztYs4gGt6rt8N>OQBIQz+QPSn6yfX>HDAy?JC0tYo1fizcgQBCBRzc2)tSqKfkQ}A} zX34S_M(X5X2sP;&&R_sCsL%2Bw%j0#OL-vKGcl>?rpwjynZiwb#~D?Cme`a4q$Gyo zdljDkAiu2hc(Kw_41e`U%qoB4JqTzJ*NC~pCn1lR$n+H?rJylL1Co`-%IkmyprUwJ zX7q-U^ZM;si>RSpoqpO02Ye3CXc$3MNjRywbf5{7J@e19OY0d`+5HCpS2Jtn7bj{r z8zQX41(#%;^~Pl+n9VU9k~*6d4GGJ6of|({zPT(?U)=Q{ZdHfxp&(Yt^_d(i( zP=u4C=Kv)Mel5lesJ&SroDUWdj`x-spg4v%%6-H%K}byLMwBbimB2s*0|AI`#en?YGcl=g#DMjcxMR+h4bHE-)(&fIynmw zPkGoAuq9mtLe+r*>>~hGYFsyzYjV+9<3xDi>|%92FKTsqso)P+^#!~AB7xPpXM))E zaWX#}Nn_7PSEzMsgc%WsFop+%>A^3b)0(~x=a6UXTuDv)&C3e<2%oVUs2IlK3p17a z!8YETC4tm|R-?2M!fRD!Yp0}GUsW6({|y$CThQsH=K<2DI0knGh*RkH+E;#X~v^W}H^U|HJ<70|eDzVD~;Js^7i9V6G68Cx5@)wjr zUbug)CN^}&&(_=}PsiJENOCabo!!l@3Y#a@%zy!(Cn{FaV$b#AigSMcEHwHMw~z1b zcv*8If$4)~eOF}hCAH|wvfu2beqri+1l<3Aw()?iSWpz-w(F2eWukF* zH?E8K5+GEzXpz^it0G(Ur)Q0PWq!B4$g-<>z_1rd84#dLMi((%&^SLRGb4f@*uxlP zL4KUzl3y$K)Y6tIEt*ZBVsb&yKu|3!IiaXE00upupB6)o)~nWluxU|EZ3;mXJ=0uv(8 z#Q$*yElyJ16)Az)%aw&g!A8mfg9KEvjgZY90Ft7{*y`4&6Ev7<%>A$q=#I;ldS<4k z76pc5(K!$u>a}9XJN!^l$%3?L+*w{7bqoV+Zl6SUSm|Px%Sgob3U#Zlmg60jBb@g3A!NZ;osUtwjkQ(OXVHw7aQ45xnj`=6p)PIU>v%(%dz|j{O#$ zrwIj%Sr78Re~dz=Ji}d4 zkk1P=LvvjekG`mS2Q||0u^IClT=_^F|8L55>`BoS2 z#o7JpyRSxPp3>d1oJ0~$-YmT!Sx4{wGSWx5oLp3kGNeQtdN=2339}Dxt77Wa699dL zxiLR1I~_e`cmva|l{8Du*iMjYEWtZ_5F=d!lp1a(CCmCp@0X@&`qPesNf(+zDeI(4 z2!Q&_*Vc_xP6fkVeU^JIy=Wq9z_FTtdu3Vrt;I5oaAz=$zsTyb>0mW%2*spKZr9@c zJ`5N}(Hn|zlf}?V(i4bySeuqXL+t`&hN|Te5g7URV8ULJW=Ys;tg?}pzp}bTMnW}h zm%rS<2Rx$xnLjfD1K}uA?7d#A-<1b4E67E$BbZ;0Y-AJZv3}694){5zJ1z+bUq^J5 zKf};(r*!|z&wI%J<*ms4*U!?T9q2*ZK2yl5O=(Y$mv zdJ|L&ks6`M$cn%LO(ct*RNM`()&Wl#UA>4x!Eq)dNhKPHo}yk}jrt0@obtYfDj(4^ zj-<)Ipj_Nf=w6d0dNLg-)cs;COzI!bzYW!&aU(oSUD}Wq4pCUQ3H3wknOS*LfH2g! z0`l)HDL3Bgp?|%zeSU8>E`JB7IjXh~R<9Gpn<4*hbWfVy^XhZHx$70_w-N`WL(2R3P`pz=WD*=QKU^PL}+0XR`a z--4fNYCo}{{`QV{D?NXK<6&9AQha@4wItFSLv{R1JC(`sbP*g8>!=DCcvu!di|n&n z-m;Ar2-TkxJ1Yn1=?%VXaeB$G@M*QShR4H&KimqKWKv(Ckq91F@up|)ww0ri5)Z=u z`5jlq+sJ7NYn_6Hv{5UAisZ&iG!)X;kzaqAxwHE(ph6^S{g~p8IQ%*$7X=>f)ql4= zy;5kDTiVw1&WFS29#djvRbzg37kVrE zvey6cFGw^POpk9}W|2vifeRTyrq2(^9rS@O9=>B3eh>12`{+{h$HlQd`>W{dg{ake z?0#V`2wrU1&+m%arm#h?P*ZC(4c~v>4UXt&*Ehc#p+oaEU#8O4sk8qLnJ@x`w(LBHBMD2ClEWeHb>1C2BMTceGf&&H-^O?_r}3y|ZT2lb^n~*RNi4Q=x6v z9UYbMWm1z*sYu`e*&z!y?WbMD!9|}k0y_olLngorK6oViG_xo_V|f1}S-;LzDaLCg znvPsd)q!z zHZ`vsT@0{e$UxKSOFO$RNch;R-v*}>`T$J zV}2%@E8BKilN?#YZG<`6+2_h{{upXBP!SlX6czQtzmvuyr2cs?N2hoY0eCp=4aX0J z=B);nh6;Xyir{fItiQ4OiUMqiLLfw4*sJx2>bzH2Ex+fUfZM*Q32xewq(dPm2)WIt zCw1;%)d-(X!m9C?z6tUV_QwJ=<*+dQ)Zc#hyt-fHVibQDFec z{ce!1M7Q{Sb&e6+PFwOHsclX8T~)*YaKKdzS@eVrg`wzkj?GHaM(&=|9H_ zYz)H!A>d<-qi$HV4Ws+K{wjZTInHKsIGGE;0SbmB2XAnqx3`@<*d2?;36!CYm#|}O zu^@gY9`elqpI1EGmn!%&o_V`p)um1Nw+$S=SH!}azWnF5FA%oM6c!OwR+>8LQ+!-t z*w_5$iJl0RP^?U)#~U$#B*bAY!PLF5Yi@;|v8z54!8{P>nxc^Fr3?lp-%vLOyz<&V zL%lF>?=%K5ztB-vj91W1b>qL5SQb-|>x4ixwbIz1)+3`gnXO7EyN%Ba%H|f+Ko4ga2Mplu!xj8z6}^>5e(I#= z;j+#z|1w}P^EQiuIm}wWT*b}FdvTLxyv8L}ZJWeFN(g27rVS2)f zJjW%D51U@o210X+-EFs~J9trbCNy2|s{Sq~rFo!UMmR}Qc@?}-92jL3D=eEM-w;1j zLFI{Z8Q;tPCubttV&LO!XaH|%`#rP0cv|e{ZNRhv{$~4!K!KKGm z(2ywhYN{vf6&uG3;o^@w156C&c*~;DE7+%EU>X`3F#464WYV|;Id)!hMx`351{H=A z)>D?%5u(dUOY1PycxZ9y+Oi@H$d&phm5Ao2&r^G1mVYht(VQWiEXC@wkROd)BEtUZ z2lnd1B{7z(@Y_!ApQ$o^|6e>OezI`-RY_P#8MN22#(yrCdAG^MdF8o zB#X9JY1@n-JX(m#aWQXFxkD9LKnhXrc*p7|3gDqSt@gEQ<*hplpRcvP&6|(JeTQO` zD{kVsNk2eof`@|eYWMy0x%$||uy3B zMX86j&kyNoz>oj~m9nbL{kF!m&qE%D$qos_l{8w|#X@O%cVC$|dr@u5XsgX&v5s9cQ`CwHUIt`V#a~@qDyH;KAM`yt~BOM{ugPNizY&R!i zd)g>l^kMINbL=mEl|KYja^u?Qkm@X|_d5-#QHH7aDN`V{z7)~twY8u90@X(6m53>` zeZ!%WGd1%eJ3aj14+KYz$k6+>J6)v6v^Fhgc1UhZ5?O;{ct(;oMsE%K4P7ZDCJ0uh z^)gJzWWm-bvujN$4)D1&QDF3 zT>)&_@Y@Zk8PcpE<)8iQCqNRo$2$c4cHWbIAuGUIwt`gSqNS|E}qT8$JN zG~9L;LXWX~ddr4t2m2NLQ5%LsY_@f@k+Mkz)S-RU0koH5cX($jSIMh>?{Dr;K(a+P zSEbRs5{KBJf&Q9pBi&F42#8;uXZh{!SiOc%K^h$(Httc@Dq=!``d8G5HYvk11N zH~UL4k!oSy^`GA9_;`fEkyO1Gwj%;qXP?x=9zpJtUoV7wip$0@RyYs`^o7%vumr(<9dXvqhQ!I+N5T=mF*0jSvaI)xAht`Xfw{VYp-akHAjJz9U#yOpLQL9D;^tU>*Y=Pf!?y|y`Y(+M5 zLpK2FA(Oxq+>ogDb+kFlQMpw#M!tnl{3UFq|3Ilu7Itu33ZOB$ehdu!osSC%I@T`x=yvHlth zRHurHuH-;}oad)Llt5mB+hbHTxO#`L&wioBS%F0pKX)($QD7(S+UpwrbCj6qN&ng~ zX_u6$dZa?XpOv${h*9(SJb+u!hmqCpk%@qdWW?y+#TQTOK77-jgy~9qjo)vXpD?&| zzv;nQ)2Yex*M3uRCWM?Y;XRBtsgVi0n^PR7!Mh|&jOc*xYRSt$@b-yA8=m9R6cu!O6Bf^RO;xP#vVqAk>YgS}@ z&9lJ(280m^=BLq;gQZ0;QJ{>;h^FG30mCCcgO=W;Lw)M6w6cXr1}N(ExbB^&Jc)CH z8OOV~XO!r(4Ss0Bf6LDQ%Gum%In;HK&+gf!19Dch6beRtMaW|><&NnW4|}15gr(5g zk@;!72JbkkB(|A?Wy~s%%TM;RF*Ye6ElI|X#uOqzPV_^2E-Wfqse~TC1+77kolBLG zfj7$b3Cac%h~{2Wr5=;U60SfSnV9^${F477caMdX(*bu zu_WY!h<@C|-J`+-!u}Cy(*Mw_d2VsU9j`f{E134XYE%JP`jqC)vYoL=)U4d-QRUFm zboo5HG!^XpD;%*6p@1(rnO?2LA@5L~Zb5V{%yC-iUJkC>r2x$C_K)$}zGjpAsv{O$ zABTG(G9laHZ5V(Ow#4$iTaf2DYFuJ=*>UX-{iHaFeiDs{##?QqsF&1WkKPfmK1O}+#ji5dqsM!<8}BBO-0Eo%PpFeo-1!AN%7 zJ^A`ccgf`kB_E}UPaR^x?ISLt2T1%M$04t`;nsdgdaDS7!8Mw^P9z+_nMK&~)6aLE z*ao7op)2A52w*bj#fh&k*qGJR)}}b!tGqjW>|@JAW!i4RH|6eaCA;Tu)p*n8fh>B4 z$HJ#2Hl~!q2H=h#FM61?V^V+{__)-dBs&ZlaNT@OO>^!MI!ay{a$RCO5nu{G{ukHH zn&buzTzu)DACh2DSQRBnXEFH})^K!|wtmiGGzjVMQQz8afEv-~04^w4 z73*-29k=4_!G?W&M5*D6(5X{Lm;=5c1-k6}3z}r^7zuEm2Qk8=Ggq;iU?zfYegL}Bugi+=I1pQt1h0?Pfy=KYWm zV%?hceuME?RXU2OZ>eKDJv(~xwG&=Zfe;9Js8nQC=os_X09C1lw{*1pX;XmpXK&>k z5qg~&T9x4s^s&Ba;lwakLgbI_2C;ZQa{HNi+Uw~^V>NtT5rQ5>palux8~C&d;)OPZ zh;Tu3kf^*-m-&9)hcsXy3Wig&9rghLP3~G6(NkXJ-MGN8v|weJ0rP|k7?NXQ%Z5*Q zOZ~5u@eQp08s;>Jxc7z!X9(TB?_yo{1`y}LA7BIdBH^(yiT*xYRV+U&7-cNTTC|!R z;-Oq;(u(lw#T&xGL(F})aYIx~2l-Y-I|KnJzz8AIx;<)z=< zoTGgRJ4oNl{m^$d5Dnj+!T<0})OxXXiUt@+rL@8gE^c!k#-JqZM_p0-?#T`SRHWeV zTb&3=F}l#!eOEd{rdz|*2L}ZqJwV$a5xjHl)0YW&1}F{JXdTmi3#TU-acdu@?{v7ZlmNUKA9^5w@KG2y&gEjU-5nKm1x`3ZMDP zX1U*ca~Z3SV>}~pq0>QZD+&5K;L;u^sd}tJ2Q>8w8~3vxaN{ew=2Oc{p-RV=^fPf# zW$$bMW5W64RAI+Ymf|SEWIM=3Bgt$5hrMF&4rQ5hewM9-xXagnLle_o#XxhYaT`qt z=rbZ_RkC3dj1AHwNFsp`CEl6$Pt24@2l#jARF?jo%a=N^&b>fUNQzT{#duSqDcFAM zJ6aBHJtFedl-{ua*7>0Dn{=bH$QW&$FYUF;M;VKG84(DP-0BWtUVDDAKl;efpjW*| zW6b8v6&5e1NUs{(ei5w-<|+=hBiYPea927~5DertFfGIl!|QTyCKcjjNsXIC;^?9jgZ%I?>@#&8h95XKuTR+9r0b{lt;p zzSbyocK-Wk_JJ>kGoh%&!pyQG%5NVg20-=H4RSPf+S}dPVY?NhTD0tkDF2SL^Ia>9 zvgW$L_-PO$ffw}Ml+n)|7t2b_6I8|>^lEPP?EZ|%>JwwxboAfR;hO#V9xtaeZuxBD z+lyd0OpgpCT~~Z-_tO8Ta?hz86)y1Hrn_Q>sqW%~l{Xgb0FVzKb3yWXB=jAq;SAFv z3K_#`qh{bpaKzUrJ+^8l5)OPK@Nc%=n-Bd9qLH1yx;8Ydoe-dQO-!>bq2?_g_WM!w z`jDksl@@N!XY55ZSUouaZ*LM3!(R*vGaCjJ=TRjvlfsT%@2Dwkk`*(lRguFs4fD3G zA#`!*eN5?hU#Ho%0Z@n{%*>zNP8nfhr6B9jY8!o3-(`{u{-Ax zM7*F`4)sWJN^X&Y!7Km!4)p+LSv^CWL1G!Qfpy)oz}dcc;S_c@?Y>7N!IPvRfb2AX2X#V8Ppepjnps+rAh=avS6;H|+Ln$1*_SL?P!gN-jKXcB@N_%IVYwO@; z@;>MAB3A#WHV(c-NnxOf#V<)fjAMJ*LbnSP67J?5;vtpkw>3PK0_9T|VjqMjB|br|>Q{ut95vkt5NLrp$a!laV1JNc z-F&pF;lYOi89SsA18=F~zv0~=NUo=?h@(o%9~Jl=cX2v+P0J|5u&58_y~8H7G&8xz zJz&;p|M?{2XaZ;qNV1c;XU7aum3Keg$lHU4jY+D4{spGc@o|BGn2!yx<&5F0<7yQa5#c(%L6(b6=tGdZqrIzooiTe$oqFnP?{wui5wE1X14Wc~~Tp*ncT412P z4Z(P_JpO5C_m2Y+EtDQf@V~mH?0$e|XU|Vw@(1m|WXXc?pxEka+OMvdXi&+X&qre+ zMdnK69*{3;)n-q$Zz62KH|5T7Xzc%m%A9mRmtP99b*vpi4RYA$0IeZ9_4m*!ihMR0 zcq~0nE>9w7jl<;*d*@2{PtFcGV=Q)pAZZp+0)PhZRLEjQEW7!)SPC+8cK}2bL-rli z@1ZZN`gX^JN|HW~oW?Yrph81>J9;6t~OixUb5P#*(k|$?T)zATX?RMmO|HsXT=j4U}dExzArJ0X#V=z@(u(n zk^)cBJxJvucM+sL$ud_2Zl)(|@n9no!93)l&yN6H5v{Y5bQXj{6jsauLr z-`-L?HNhVBi-Q!AL#?hka#}jxvPxM|PoacKZJ8dA)&RfA5FQ+LGIgInm$N?zNjMBL zOD1TDEY@ZAUcp1n16-_ literal 0 HcmV?d00001 diff --git a/packages/arepa-wallet/jest.config.js b/packages/arepa-wallet/jest.config.js new file mode 100644 index 000000000..fa21e8daf --- /dev/null +++ b/packages/arepa-wallet/jest.config.js @@ -0,0 +1,14 @@ +module.exports = { + displayName: "arepa-wallet", + preset: "../../jest.preset.js", + globals: { + "ts-jest": { + tsconfig: "/tsconfig.spec.json", + }, + }, + transform: { + "^.+\\.[tj]sx?$": "ts-jest", + }, + moduleFileExtensions: ["ts", "tsx", "js", "jsx"], + coverageDirectory: "../../coverage/packages/arepa-wallet", +}; diff --git a/packages/arepa-wallet/jest.config.ts b/packages/arepa-wallet/jest.config.ts new file mode 100644 index 000000000..531d03520 --- /dev/null +++ b/packages/arepa-wallet/jest.config.ts @@ -0,0 +1,16 @@ +/* eslint-disable */ +export default { + displayName: "arepa-wallet", + preset: "../../jest.preset.js", + globals: {}, + transform: { + "^.+\\.[tj]s$": [ + "ts-jest", + { + tsconfig: "/tsconfig.spec.json", + }, + ], + }, + moduleFileExtensions: ["ts", "tsx", "js", "jsx"], + coverageDirectory: "../../coverage/packages/arepa-wallet", +}; diff --git a/packages/arepa-wallet/package.json b/packages/arepa-wallet/package.json new file mode 100644 index 000000000..7e4c5934d --- /dev/null +++ b/packages/arepa-wallet/package.json @@ -0,0 +1,27 @@ +{ + "name": "@near-wallet-selector/arepa-wallet", + "version": "8.9.7", + "description": "Arepa Wallet package for NEAR Wallet Selector.", + "keywords": [ + "near", + "blockchain", + "wallets", + "dapps", + "near-protocol", + "near-blockchain", + "wallet selector", + "browser wallet", + "arepa Wallet" + ], + "repository": { + "type": "git", + "url": "https://github.com/near/wallet-selector.git" + }, + "bugs": { + "url": "https://github.com/near/wallet-selector/issues" + }, + "homepage": "https://github.com/near/wallet-selector/tree/main/packages/arepa-wallet", + "peerDependencies": { + "near-api-js": "^1.0.0 || ^2.0.0" + } +} diff --git a/packages/arepa-wallet/project.json b/packages/arepa-wallet/project.json new file mode 100644 index 000000000..877484034 --- /dev/null +++ b/packages/arepa-wallet/project.json @@ -0,0 +1,56 @@ +{ + "name": "arepa-wallet", + "$schema": "../../node_modules/nx/schemas/project-schema.json", + "sourceRoot": "packages/arepa-wallet/src", + "projectType": "library", + "targets": { + "build": { + "executor": "@nrwl/rollup:rollup", + "outputs": ["{options.outputPath}"], + "options": { + "outputPath": "dist/packages/arepa-wallet", + "tsConfig": "packages/arepa-wallet/tsconfig.lib.json", + "project": "packages/arepa-wallet/package.json", + "entryFile": "packages/arepa-wallet/src/index.ts", + "buildableProjectDepsInPackageJsonType": "dependencies", + "compiler": "babel", + "format": ["esm", "cjs"], + "assets": [ + { + "glob": "packages/arepa-wallet/README.md", + "input": ".", + "output": "." + }, + { + "glob": "packages/arepa-wallet/assets/*", + "input": ".", + "output": "assets" + } + ] + } + }, + "lint": { + "executor": "@nx/linter:eslint", + "outputs": ["{options.outputFile}"], + "options": { + "lintFilePatterns": ["packages/arepa-wallet/**/*.ts"] + } + }, + "test": { + "executor": "@nx/jest:jest", + "outputs": ["{workspaceRoot}/coverage/packages/arepa-wallet"], + "options": { + "jestConfig": "packages/arepa-wallet/jest.config.ts", + "passWithNoTests": true + } + }, + "deploy": { + "executor": "ngx-deploy-npm:deploy", + "options": { + "access": "public" + }, + "dependsOn": ["^deploy"] + } + }, + "tags": ["browser-wallet"] +} diff --git a/packages/arepa-wallet/src/index.ts b/packages/arepa-wallet/src/index.ts new file mode 100644 index 000000000..66360c65d --- /dev/null +++ b/packages/arepa-wallet/src/index.ts @@ -0,0 +1,2 @@ +export { setupArepaWallet } from "./lib/arepa-wallet"; +export type { ArepaWalletParams } from "./lib/arepa-wallet"; diff --git a/packages/arepa-wallet/src/lib/arepa-wallet.spec.ts b/packages/arepa-wallet/src/lib/arepa-wallet.spec.ts new file mode 100644 index 000000000..edfff1118 --- /dev/null +++ b/packages/arepa-wallet/src/lib/arepa-wallet.spec.ts @@ -0,0 +1,121 @@ +/* eslint-disable @nx/enforce-module-boundaries */ +import type { + Near, + WalletConnection, + ConnectedWalletAccount, +} from "near-api-js"; +import type { AccountView } from "near-api-js/lib/providers/provider"; +import { mock } from "jest-mock-extended"; + +import { mockWallet } from "../../../core/src/lib/testUtils"; +import type { MockWalletDependencies } from "../../../core/src/lib/testUtils"; +import type { BrowserWallet } from "../../../core/src/lib/wallet"; + +const createArepaWallet = async (deps: MockWalletDependencies = {}) => { + const walletConnection = mock(); + const account = mock({ + connection: { + signer: { + getPublicKey: jest.fn().mockReturnValue(""), + }, + }, + }); + + jest.mock("near-api-js", () => { + const module = jest.requireActual("near-api-js"); + return { + ...module, + connect: jest.fn().mockResolvedValue(mock()), + WalletConnection: jest.fn().mockReturnValue(walletConnection), + }; + }); + + walletConnection.isSignedIn.calledWith().mockReturnValue(true); + walletConnection.getAccountId + .calledWith() + .mockReturnValue("test-account.testnet"); + walletConnection.account.calledWith().mockReturnValue(account); + // @ts-ignore + // near-api-js marks this method as protected. + // TODO: return value instead of null + account.signAndSendTransaction.calledWith().mockReturnValue(null); + account.state.calledWith().mockResolvedValue( + mock({ + amount: "1000000000000000000000000", + }) + ); + + // eslint-disable-next-line @typescript-eslint/no-var-requires + const { setupArepaWallet } = require("./arepa-wallet"); + const { wallet } = await mockWallet(setupArepaWallet(), deps); + + return { + nearApiJs: require("near-api-js"), + wallet, + walletConnection, + account, + }; +}; + +afterEach(() => { + jest.resetModules(); +}); + +describe("signIn", () => { + it("sign into near wallet", async () => { + const { wallet, nearApiJs } = await createArepaWallet(); + + await wallet.signIn({ contractId: "test.testnet" }); + + expect(nearApiJs.connect).toHaveBeenCalled(); + }); +}); + +describe("signOut", () => { + it("sign out of near wallet", async () => { + const { wallet, walletConnection } = await createArepaWallet(); + + await wallet.signIn({ contractId: "test.testnet" }); + await wallet.signOut(); + + expect(walletConnection.signOut).toHaveBeenCalled(); + }); +}); + +describe("getAccounts", () => { + it("returns array of accounts", async () => { + const { wallet, walletConnection } = await createArepaWallet(); + + await wallet.signIn({ contractId: "test.testnet" }); + const result = await wallet.getAccounts(); + + expect(walletConnection.getAccountId).toHaveBeenCalled(); + expect(result).toEqual([ + { accountId: "test-account.testnet", publicKey: "" }, + ]); + }); +}); + +describe("signAndSendTransaction", () => { + // TODO: Figure out why imports to core are returning undefined. + it("signs and sends transaction", async () => { + const { wallet, walletConnection, account } = await createArepaWallet(); + + await wallet.signIn({ contractId: "test.testnet" }); + const result = await wallet.signAndSendTransaction({ + receiverId: "guest-book.testnet", + actions: [], + }); + + expect(walletConnection.account).toHaveBeenCalled(); + // near-api-js marks this method as protected. + // @ts-ignore + expect(account.signAndSendTransaction).toHaveBeenCalled(); + // @ts-ignore + expect(account.signAndSendTransaction).toBeCalledWith({ + actions: [], + receiverId: "guest-book.testnet", + }); + expect(result).toEqual(null); + }); +}); diff --git a/packages/arepa-wallet/src/lib/arepa-wallet.ts b/packages/arepa-wallet/src/lib/arepa-wallet.ts new file mode 100644 index 000000000..4be01ca12 --- /dev/null +++ b/packages/arepa-wallet/src/lib/arepa-wallet.ts @@ -0,0 +1,271 @@ +import * as nearAPI from "near-api-js"; +import type { + WalletModuleFactory, + WalletBehaviourFactory, + BrowserWallet, + Transaction, + Optional, + Network, + Account, +} from "@near-wallet-selector/core"; +import { createAction } from "@near-wallet-selector/wallet-utils"; +import icon from "./icon"; + +export interface ArepaWalletParams { + walletUrl?: string; + iconUrl?: string; + deprecated?: boolean; + successUrl?: string; + failureUrl?: string; +} + +interface ArepaWalletState { + wallet: nearAPI.WalletConnection; + keyStore: nearAPI.keyStores.BrowserLocalStorageKeyStore; +} + +interface ArepaWalletExtraOptions { + walletUrl: string; +} + +const resolveWalletUrl = (network: Network, walletUrl?: string) => { + if (walletUrl) { + return walletUrl; + } + + switch (network.networkId) { + case "mainnet": + return "https://mi.arepa.digital"; + case "testnet": + return "https://testnet.arepa.digital"; + default: + throw new Error("Invalid wallet url"); + } +}; + +const setupWalletState = async ( + params: ArepaWalletExtraOptions, + network: Network +): Promise => { + const keyStore = new nearAPI.keyStores.BrowserLocalStorageKeyStore(); + + const near = await nearAPI.connect({ + keyStore, + walletUrl: params.walletUrl, + ...network, + headers: {}, + }); + + const wallet = new nearAPI.WalletConnection(near, "near_app"); + + return { + wallet, + keyStore, + }; +}; + +const ArepaWallet: WalletBehaviourFactory< + BrowserWallet, + { params: ArepaWalletExtraOptions } +> = async ({ metadata, options, store, params, logger, id }) => { + const _state = await setupWalletState(params, options.network); + const getAccounts = async (): Promise> => { + const accountId = _state.wallet.getAccountId(); + const account = _state.wallet.account(); + + if (!accountId || !account) { + return []; + } + + const publicKey = await account.connection.signer.getPublicKey( + account.accountId, + options.network.networkId + ); + return [ + { + accountId, + publicKey: publicKey ? publicKey.toString() : "", + }, + ]; + }; + + const transformTransactions = async ( + transactions: Array> + ) => { + const account = _state.wallet.account(); + const { networkId, signer, provider } = account.connection; + + const localKey = await signer.getPublicKey(account.accountId, networkId); + + return Promise.all( + transactions.map(async (transaction, index) => { + const actions = transaction.actions.map((action) => + createAction(action) + ); + const accessKey = await account.accessKeyForTransaction( + transaction.receiverId, + actions, + localKey + ); + + if (!accessKey) { + throw new Error( + `Failed to find matching key for transaction sent to ${transaction.receiverId}` + ); + } + + const block = await provider.block({ finality: "final" }); + + return nearAPI.transactions.createTransaction( + account.accountId, + nearAPI.utils.PublicKey.from(accessKey.public_key), + transaction.receiverId, + accessKey.access_key.nonce + index + 1, + actions, + nearAPI.utils.serialize.base_decode(block.header.hash) + ); + }) + ); + }; + + return { + async signIn({ contractId, methodNames, successUrl, failureUrl }) { + const existingAccounts = await getAccounts(); + + if (existingAccounts.length) { + return existingAccounts; + } + + await _state.wallet.requestSignIn({ + contractId, + methodNames, + successUrl, + failureUrl, + }); + + return getAccounts(); + }, + + async signOut() { + if (_state.wallet.isSignedIn()) { + _state.wallet.signOut(); + } + }, + + async getAccounts() { + return getAccounts(); + }, + + async verifyOwner() { + throw new Error(`Method not supported by ${metadata.name}`); + }, + + async signMessage({ message, nonce, recipient, callbackUrl, state }) { + logger.log("sign message", { message }); + + if (id !== "arepa-wallet") { + throw Error( + `The signMessage method is not supported by ${metadata.name}` + ); + } + + const locationUrl = + typeof window !== "undefined" ? window.location.href : ""; + + const url = callbackUrl || locationUrl; + + if (!url) { + throw new Error(`The callbackUrl is missing for ${metadata.name}`); + } + + const href = new URL(params.walletUrl); + href.pathname = "sign-message"; + href.searchParams.append("message", message); + href.searchParams.append("nonce", nonce.toString("base64")); + href.searchParams.append("recipient", recipient); + href.searchParams.append("callbackUrl", url); + if (state) { + href.searchParams.append("state", state); + } + + window.location.replace(href.toString()); + + return; + }, + + async signAndSendTransaction({ + signerId, + receiverId, + actions, + callbackUrl, + }) { + logger.log("signAndSendTransaction", { + signerId, + receiverId, + actions, + callbackUrl, + }); + + const { contract } = store.getState(); + + if (!_state.wallet.isSignedIn() || !contract) { + throw new Error("Wallet not signed in"); + } + + const account = _state.wallet.account(); + + return account["signAndSendTransaction"]({ + receiverId: receiverId || contract.contractId, + actions: actions.map((action) => createAction(action)), + walletCallbackUrl: callbackUrl, + }); + }, + + async signAndSendTransactions({ transactions, callbackUrl }) { + logger.log("signAndSendTransactions", { transactions, callbackUrl }); + + if (!_state.wallet.isSignedIn()) { + throw new Error("Wallet not signed in"); + } + + return _state.wallet.requestSignTransactions({ + transactions: await transformTransactions(transactions), + callbackUrl, + }); + }, + }; +}; + +export function setupArepaWallet({ + walletUrl, + iconUrl = icon, + deprecated = false, + successUrl = "", + failureUrl = "", +}: ArepaWalletParams = {}): WalletModuleFactory { + return async (moduleOptions) => { + return { + id: "arepa-wallet", + type: "browser", + metadata: { + name: "ArepaWallet", + description: + "NEAR wallet to store, buy, send and stake assets for DeFi.", + iconUrl, + deprecated, + available: true, + successUrl, + failureUrl, + walletUrl: resolveWalletUrl(moduleOptions.options.network, walletUrl), + }, + init: (options) => { + return ArepaWallet({ + ...options, + params: { + walletUrl: resolveWalletUrl(options.options.network, walletUrl), + }, + }); + }, + }; + }; +} diff --git a/packages/arepa-wallet/src/lib/icon.ts b/packages/arepa-wallet/src/lib/icon.ts new file mode 100644 index 000000000..b3d406ad9 --- /dev/null +++ b/packages/arepa-wallet/src/lib/icon.ts @@ -0,0 +1 @@ +export default `data:image/png;base64,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`; diff --git a/packages/arepa-wallet/tsconfig.json b/packages/arepa-wallet/tsconfig.json new file mode 100644 index 000000000..8b6d6acaf --- /dev/null +++ b/packages/arepa-wallet/tsconfig.json @@ -0,0 +1,19 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "forceConsistentCasingInFileNames": true, + "strict": true, + "noImplicitReturns": true, + "noFallthroughCasesInSwitch": true + }, + "files": [], + "include": [], + "references": [ + { + "path": "./tsconfig.lib.json" + }, + { + "path": "./tsconfig.spec.json" + } + ] +} diff --git a/packages/arepa-wallet/tsconfig.lib.json b/packages/arepa-wallet/tsconfig.lib.json new file mode 100644 index 000000000..b3f90c22f --- /dev/null +++ b/packages/arepa-wallet/tsconfig.lib.json @@ -0,0 +1,10 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "../../dist/out-tsc", + "declaration": true, + "types": [] + }, + "include": ["**/*.ts"], + "exclude": ["jest.config.ts", "**/*.spec.ts"] +} diff --git a/packages/arepa-wallet/tsconfig.spec.json b/packages/arepa-wallet/tsconfig.spec.json new file mode 100644 index 000000000..546f12877 --- /dev/null +++ b/packages/arepa-wallet/tsconfig.spec.json @@ -0,0 +1,9 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "../../dist/out-tsc", + "module": "commonjs", + "types": ["jest", "node"] + }, + "include": ["jest.config.ts", "**/*.test.ts", "**/*.spec.ts", "**/*.d.ts"] +} diff --git a/tsconfig.base.json b/tsconfig.base.json index b175e61fc..702d746c7 100644 --- a/tsconfig.base.json +++ b/tsconfig.base.json @@ -30,6 +30,9 @@ "@near-wallet-selector/account-export": [ "packages/account-export/src/index.ts" ], + "@near-wallet-selector/arepa-wallet": [ + "packages/arepa-wallet/src/index.ts" + ], "@near-wallet-selector/bitget-wallet": [ "packages/bitget-wallet/src/index.ts" ], From c92a85d05a865f1a9a3af4d8ba1b9bf9d650e294 Mon Sep 17 00:00:00 2001 From: Hector Palencia Date: Wed, 4 Sep 2024 12:11:38 -0400 Subject: [PATCH 2/4] chore: Update near-api-js dependency to version 4.0.3 --- packages/arepa-wallet/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/arepa-wallet/package.json b/packages/arepa-wallet/package.json index 7e4c5934d..b0fe9760e 100644 --- a/packages/arepa-wallet/package.json +++ b/packages/arepa-wallet/package.json @@ -22,6 +22,6 @@ }, "homepage": "https://github.com/near/wallet-selector/tree/main/packages/arepa-wallet", "peerDependencies": { - "near-api-js": "^1.0.0 || ^2.0.0" + "near-api-js": "4.0.3" } } From 9c8b4f3d082bff1ae71cdf3ac384ce74deb960b9 Mon Sep 17 00:00:00 2001 From: Hector Palencia Date: Wed, 4 Sep 2024 12:23:26 -0400 Subject: [PATCH 3/4] chore: Update near-api-js dependency to version 4.0.0 --- packages/arepa-wallet/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/arepa-wallet/package.json b/packages/arepa-wallet/package.json index b0fe9760e..9e48bb497 100644 --- a/packages/arepa-wallet/package.json +++ b/packages/arepa-wallet/package.json @@ -22,6 +22,6 @@ }, "homepage": "https://github.com/near/wallet-selector/tree/main/packages/arepa-wallet", "peerDependencies": { - "near-api-js": "4.0.3" + "near-api-js": "4.0.0" } } From 93a2bb65d4d2e7557b13ada2639248bd8268ab73 Mon Sep 17 00:00:00 2001 From: Hector Palencia Date: Wed, 4 Sep 2024 12:24:39 -0400 Subject: [PATCH 4/4] chore: Update near-api-js dependency to version 4.0.3 --- packages/arepa-wallet/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/arepa-wallet/package.json b/packages/arepa-wallet/package.json index 9e48bb497..b0fe9760e 100644 --- a/packages/arepa-wallet/package.json +++ b/packages/arepa-wallet/package.json @@ -22,6 +22,6 @@ }, "homepage": "https://github.com/near/wallet-selector/tree/main/packages/arepa-wallet", "peerDependencies": { - "near-api-js": "4.0.0" + "near-api-js": "4.0.3" } }