deso-protocol - npm Package Compare versions

Comparing version 2.0.0-beta.0 to 2.0.0-beta.1

package.json

 {
   "name": "deso-protocol",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.1",
   "license": "MIT",
@@ -5,0 +5,0 @@ "description": "Client side typescript/javascript SDK for building web3 applications for the DeSo blockchain.",

README.md

@@ -13,3 +13,3 @@ # deso-protocol
 
-```ts
+````ts
 import { configure } from 'deso-protocol';
@@ -56,4 +56,31 @@
   MinFeeRateNanosPerKB: 1000,
+
+
+  // THE FOLLOWING CONFIGURATIONS ARE ONLY NEEDED IN A REACT NATIVE CONTEXT
+
+  /**
+   * An optional storage provider. If not provided, we will assume localStorage
+   * is available. In react native this will typically be an async storage
+   * class.
+   */
+  storageProvider?: Storage | AsyncStorage;
+
+  /**
+   * An optional function that is provided the identity url that needs to be
+   * opened. This can be used to customize how the identity url is opened. For
+   * example, if you are using react native, you might want to use the WebBrowser
+   * API to open the url in a system browser window.
+   * @example
+   * ```ts
+   * identityPresenter: async (url) => {
+   *   const result = await WebBrowser.openAuthSessionAsync(url);
+   *   if (result.type === 'success') {
+   *     identity.handleRedirectURI(result.url);
+   *   }
+   * },
+   * ```
+   */
+  identityPresenter?: (url: string) => void;
 })
-```
+````
 
@@ -202,2 +229,89 @@ ## Usage
 
+## React Native (beta)
+
+React native support is a work in progress, but there is a beta version
+available if you'd like to test to it out. You will need to run react native
+version `0.71.7` or later to ensure `BigInt` support is available.
+
+### Installation
+
+```sh
+npm i deso-protocol@beta
+```
+
+There a few peer dependencies that are required for everything to work smoothly.
+
+```sh
+npm i react-native-get-random-values react-native-webview react-native-webview-crypto text-encoding @react-native-async-storage/async-storage @ethersproject/shims
+```
+
+NOTE: you may need to install native modules for the target platform. For iOS you can do this via cocoapods:
+
+```sh
+cd ios && pod install && cd -
+```
+
+You will need to add these shims to your application:
+
+```ts
+// NOTE: shims must be imported into index.js before anything else and the order
+// is important!
+import 'react-native-get-random-values';
+
+// The deso-protocol lib depends on the ethers library. See the following for more info:
+// https://docs.ethers.org/v5/cookbook/react-native/
+import '@ethersproject/shims';
+
+// deso-protocol needs TextEncoder/Decoder and expects it in the global scope
+import { TextDecoder, TextEncoder } from 'text-encoding';
+
+if (typeof global.TextEncoder === 'undefined') {
+  global.TextEncoder = TextEncoder;
+}
+
+if (typeof global.TextDecoder === 'undefined') {
+  global.TextDecoder = TextDecoder;
+}
+```
+
+`deso-protocol` requires the web crypto APIs, which are provided via
+the
+[react-native-webview-crypto](https://github.com/webview-crypto/react-native-webview-crypto)
+package. TL;DR you need to render a hidden webview at the top level of your app
+to proxy crypto method calls to, so please pay special attention to their [usage
+documentation](https://github.com/webview-crypto/react-native-webview-crypto#usage).
+
+And finally you will need to configure `deso-protocol` with a `redirectURI`, `identityPresenter`, and `storageProvider`.
+If you are using [Expo](https://expo.dev) it is very easy to set things up.
+
+```ts
+import { configure } from 'deso-protocol';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as AuthSession from 'expo-auth-session';
+import * as WebBrowser from 'expo-web-browser';
+
+configure({
+  // This is the deep link back into your application. NOTE: You will need to
+  // set a scheme value in your app.json
+  redirectURI: AuthSession.makeRedirectUri(),
+
+  // This will open the identity login page in the system browser, and once the
+  // browser flow is complete the result object will have the payload passed
+  // back from identity in the query parameters.
+  identityPresenter: async (url) => {
+    const result = await WebBrowser.openAuthSessionAsync(url);
+    if (result.type === 'success') {
+      identity.handleRedirectURI(result.url);
+    }
+  },
+
+  // This will be the persistent storage used to keep people logged in.
+  // For this example we're using @react-native-async-storage/async-storage
+  // but there are several other options that could work https://reactnative.directory/?search=storage
+  storageProvider: AsyncStorage,
+
+  // ...rest of configs
+});
+```
+
 ## Contributing
@@ -204,0 +318,0 @@

src/identity/identity.d.ts

@@ -50,3 +50,3 @@ import { type AccessGroupEntryResponse, type DecryptedMessageEntryResponse, type NewMessageEntryResponse, type SubmitTransactionResponse, type TransactionSpendingLimitResponse } from '../backend-types';
      */
-    configure({ identityURI, network, nodeURI, spendingLimitOptions, redirectURI, jwtAlgorithm, appName, storageProvider, identityPresenter, identityRedirectResolver, }: IdentityConfiguration): void;
+    configure({ identityURI, network, nodeURI, spendingLimitOptions, redirectURI, jwtAlgorithm, appName, storageProvider, identityPresenter, }: IdentityConfiguration): void;
     /**
@@ -398,3 +398,9 @@ * Allows listening to changes to identity state. The subscriber will be
     ethereumAddressToDesoAddress(address: string): Promise<string>;
+    /**
+     * Method to handle the redirect URI from the identity service. Typically this
+     * would be useful in a mobile context where the user is redirected back to
+     * the app after completing the identity flow.
+     */
+    handleRedirectURI(redirectURI: string): void;
 }
 export declare const identity: Identity;

src/identity/types.d.ts

@@ -119,4 +119,7 @@ import { AccessGroupLimitMapItem, AccessGroupMemberLimitMapItem, AssociationLimitMapItem, TransactionSpendingLimitResponse, TransactionType } from '../backend-types';
      * ```ts
-     * identityPresenter: (url) => {
-     *   WebBrowser.openBrowserAsync(url);
+     * identityPresenter: async (url) => {
+     *   const result = await WebBrowser.openAuthSessionAsync(url);
+     *   if (result.type === 'success') {
+     *     identity.handleRedirectURI(result.url);
+     *   }
      * },
@@ -126,22 +129,2 @@ * ```
     identityPresenter?: (url: string) => void;
-    /**
-     * A function that returns a promise that resolves to a
-     * redirect url. This would be used in the context of react native application
-     * that needs to propagate the redirect url to the identity library.
-     * NOTE: This is required if you are using a custom identityPresenter.
-     * @example
-     * ```ts
-     *   identityRedirectResolver: () => {
-     *     return new Promise((resolve) => {
-     *       // This is an example of how you might use the Linking API in react native,
-     *       // assuming you've opened a browser window to the identity domain.
-     *       Linking.addEventListener('url', ({ url }) => {
-     *         WebBrowser.dismissBrowser();
-     *         resolve(url);
-     *       });
-     *     });
-     *   },
-     * ```
-     */
-    identityRedirectResolver?: () => Promise<string>;
 }
@@ -148,0 +131,0 @@ export interface APIProvider {

src/identity/types.js

@@ -73,2 +73,2 @@ export var NOTIFICATION_EVENTS;
 })(NOTIFICATION_EVENTS || (NOTIFICATION_EVENTS = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/identity/types.ts"],"names":[],"mappings":"AA8QA,MAAM,CAAN,IAAY,mBAoFX;AApFD,WAAY,mBAAmB;IAC7B;;OAEG;IACH,8CAAuB,CAAA;IAEvB;;;;OAIG;IACH,kFAA2D,CAAA;IAE3D;;;;OAIG;IACH,8EAAuD,CAAA;IAEvD;;OAEG;IACH,gFAAyD,CAAA;IAEzD;;OAEG;IACH,8EAAuD,CAAA;IAEvD;;;OAGG;IACH,0EAAmD,CAAA;IAEnD;;OAEG;IACH,kDAA2B,CAAA;IAE3B;;;OAGG;IACH,8CAAuB,CAAA;IAEvB;;OAEG;IACH,oDAA6B,CAAA;IAE7B;;;OAGG;IACH,gDAAyB,CAAA;IAEzB;;OAEG;IACH,kEAA2C,CAAA;IAE3C;;;OAGG;IACH,8DAAuC,CAAA;IAEvC;;OAEG;IACH,8EAAuD,CAAA;IAEvD;;;OAGG;IACH,0EAAmD,CAAA;IAEnD;;OAEG;IACH,gEAAyC,CAAA;AAC3C,CAAC,EApFW,mBAAmB,KAAnB,mBAAmB,QAoF9B","sourcesContent":["import {\n  AccessGroupLimitMapItem,\n  AccessGroupMemberLimitMapItem,\n  AssociationLimitMapItem,\n  TransactionSpendingLimitResponse,\n  TransactionType,\n} from '../backend-types';\nexport type Network = 'mainnet' | 'testnet';\n\nexport interface IdentityResponse {\n  service: 'identity';\n  method: 'derive' | 'login' | 'initialize';\n  payload?: any;\n  id?: string;\n}\n\nexport interface IdentityDerivePayload {\n  derivedSeedHex?: string;\n  derivedPublicKeyBase58Check: string;\n  publicKeyBase58Check: string;\n  btcDepositAddress: string;\n  ethDepositAddress: string;\n  expirationBlock: number;\n  network: Network;\n  accessSignature: string;\n  jwt: string;\n  derivedJwt: string;\n  messagingPublicKeyBase58Check: string;\n  messagingPrivateKey: string;\n  messagingKeyName: string;\n  messagingKeySignature: string;\n  transactionSpendingLimitHex: string;\n  signedUp: boolean;\n  publicKeyAdded?: string;\n}\n\nexport interface TransactionSpendingLimitResponseOptions {\n  GlobalDESOLimit?: number;\n  TransactionCountLimitMap?: Partial<\n    Record<TransactionType, number | 'UNLIMITED'>\n  >;\n  CreatorCoinOperationLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  DAOCoinOperationLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  NFTOperationLimitMap?: {\n    [key: string]: { [key: number]: { [key: string]: number | 'UNLIMITED' } };\n  };\n  DAOCoinLimitOrderLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  AssociationLimitMap?: (Omit<AssociationLimitMapItem, 'OpCount'> & {\n    OpCount: number | 'UNLIMITED';\n  })[];\n  AccessGroupLimitMap?: (Omit<AccessGroupLimitMapItem, 'OpCount'> & {\n    OpCount: number | 'UNLIMITED';\n  })[];\n  AccessGroupMemberLimitMap?: (Omit<\n    AccessGroupMemberLimitMapItem,\n    'OpCount'\n  > & { OpCount: number | 'UNLIMITED' })[];\n  IsUnlimited?: boolean;\n}\n\nexport type jwtAlgorithm = 'ES256K' | 'ES256';\nexport interface IdentityConfiguration {\n  /**\n   * The identity domain. Defaults to https://identity.deso.org\n   */\n  identityURI?: string;\n\n  /**\n   * The current network. If not provided, we will assume mainnet.\n   */\n  network?: Network;\n\n  /**\n   * The deso node used for any api calls (get balance, derived key authorization, etc)\n   */\n  nodeURI?: string;\n\n  /**\n   * Optional redirect URI. If provided, we do a hard redirect to the identity\n   * domain and pass data via query params back to the provided uri.\n   */\n  redirectURI?: string;\n\n  /**\n   * The default permissions and spending limits that will be presented to the user\n   * during login. If not provided, we will assume no permissions.\n   */\n  spendingLimitOptions?: TransactionSpendingLimitResponseOptions;\n\n  /**\n   * The name of the app used to authorize derived keys. Defaults to unknown.\n   */\n  appName?: string;\n\n  /**\n   * Since our keys are generated using the secp256k1 curve, the correct\n   * JWT algorithm header *should* be ES256K.\n   * See: https://www.rfc-editor.org/rfc/rfc8812.html#name-jose-algorithms-registratio\n   *\n   * HOWEVER, the backend jwt lib used by deso foundation -\n   * https://github.com/golang-jwt/jwt - (as well as many other jwt libraries)\n   * do not support ES256K. So instead, we default to the more widely supported ES256 algo,\n   * which can still work for verifying our signatures. But if a consumer of this lib is using a\n   * jwt lib that supports ES256K they can specify that here.\n   * See this github issue\n   * for more context: https://github.com/auth0/node-jsonwebtoken/issues/862\n   * If ES256K is ever supported by the backend jwt lib, we should change this.\n   */\n  jwtAlgorithm?: jwtAlgorithm;\n\n  /**\n   * An optional storage provider. If not provided, we will assume localStorage\n   * is available.\n   */\n  storageProvider?: Storage | AsyncStorage;\n\n  /**\n   * An optional function that is provided the identity url that needs to be\n   * opened. This can be used to customize how the identity url is opened. For\n   * example, if you are using react native, you might want to use the Linking\n   * API to open the url in a system browser window.\n   * @example\n   * ```ts\n   * identityPresenter: (url) => {\n   *   WebBrowser.openBrowserAsync(url);\n   * },\n   * ```\n   */\n  identityPresenter?: (url: string) => void;\n\n  /**\n   * A function that returns a promise that resolves to a\n   * redirect url. This would be used in the context of react native application\n   * that needs to propagate the redirect url to the identity library.\n   * NOTE: This is required if you are using a custom identityPresenter.\n   * @example\n   * ```ts\n   *   identityRedirectResolver: () => {\n   *     return new Promise((resolve) => {\n   *       // This is an example of how you might use the Linking API in react native,\n   *       // assuming you've opened a browser window to the identity domain.\n   *       Linking.addEventListener('url', ({ url }) => {\n   *         WebBrowser.dismissBrowser();\n   *         resolve(url);\n   *       });\n   *     });\n   *   },\n   * ```\n   */\n  identityRedirectResolver?: () => Promise<string>;\n}\n\nexport interface APIProvider {\n  post: (url: string, data: any) => Promise<any>;\n  get: (url: string) => Promise<any>;\n}\n\nexport interface WindowProvider {\n  location: { search: string; pathname: string; href: string };\n  history: { replaceState: (state: any, title: string, url: string) => void };\n  localStorage: {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n  };\n  open: (\n    url: string,\n    title: string | undefined,\n    options: string\n  ) => Window | null;\n  addEventListener: (event: string, callback: (event: any) => void) => void;\n  removeEventListener: (event: string, callback: (event: any) => void) => void;\n}\n\nexport interface LoginOptions {\n  getFreeDeso: boolean;\n}\n\nexport type PrimaryDerivedKeyInfo = IdentityDerivePayload & {\n  transactionSpendingLimits: TransactionSpendingLimitResponse;\n  IsValid?: boolean;\n};\n\nexport type StoredUser = {\n  publicKey: string;\n  primaryDerivedKey: PrimaryDerivedKeyInfo;\n};\n\nexport interface IdentityUser {\n  accessLevel: number;\n  accessLevelHmac: string;\n  btcDepositAddress: string;\n  encryptedSeedHex: string;\n  ethDepositAddress: string;\n  derivedPublicKeyBase58Check?: string;\n  hasExtraText: boolean;\n  network: string;\n  version: number;\n}\n\nexport interface IdentityLoginPayload {\n  users: Record<string, IdentityUser>;\n  publicKeyAdded: string;\n  phoneNumberSuccess: boolean;\n  signedUp: boolean;\n}\n\nexport interface IdentityState {\n  currentUser: StoredUser | null;\n  alternateUsers: Record<string, StoredUser> | null;\n}\n\nexport interface Deferred {\n  resolve: (args: any) => void;\n  reject: (args: any) => void;\n}\n\nexport interface KeyPair {\n  seedHex: string;\n  private: Uint8Array;\n  public: Uint8Array;\n}\n\nexport interface SubscriberNotification {\n  event: NOTIFICATION_EVENTS;\n  currentUser: StoredUser | null;\n  alternateUsers: Record<string, StoredUser> | null;\n}\n\nexport interface EtherscanTransactionsByAddressResponse {\n  status: string;\n  message: string;\n  result: EtherscanTransaction[];\n}\n\nexport interface EtherscanTransaction {\n  blockNumber: string;\n  timestamp: string;\n  hash: string;\n  nonce: string;\n  blockHash: string;\n  transactionIndex: string;\n  from: string;\n  to: string;\n  value: string;\n  gas: string;\n  gasPrice: string;\n  isError: string;\n  txreceipt_status: string;\n  input: string;\n  contractAddress: string;\n  cumulativeGasUsed: string;\n  gasUsed: string;\n  confirmations: string;\n  methodId: string;\n  functionName: string;\n}\n\nexport interface AccessGroupPrivateInfo {\n  AccessGroupPublicKeyBase58Check: string;\n  AccessGroupPrivateKeyHex: string;\n  AccessGroupKeyName: string;\n}\n\nexport enum NOTIFICATION_EVENTS {\n  /**\n   * This event is fired when the consuming app initially subscribes to identity.\n   */\n  SUBSCRIBE = 'SUBSCRIBE',\n\n  /**\n   * This is an intermediate event fired AFTER the user completes an identity flow\n   * that requires a derived key authorization. This event is fired BEFORE the\n   * request to authorize the derived key is made.\n   */\n  AUTHORIZE_DERIVED_KEY_START = 'AUTHORIZE_DERIVED_KEY_START',\n\n  /**\n   * This is an intermediate event fired AFTER the user completes an identity\n   * flow that requires a derived key authorization. This event is fired AFTER\n   * the request to authorize the derived key is made.\n   */\n  AUTHORIZE_DERIVED_KEY_END = 'AUTHORIZE_DERIVED_KEY_END',\n\n  /**\n   * This event is fired if the request to authorize a derived key fails.\n   */\n  AUTHORIZE_DERIVED_KEY_FAIL = 'AUTHORIZE_DERIVED_KEY_FAIL',\n\n  /**\n   * This event is fired when the user opens the permissions approval popup.\n   */\n  REQUEST_PERMISSIONS_START = 'REQUEST_PERMISSIONS_START',\n\n  /**\n   * This event is fired when the user completes approving permissions, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  REQUEST_PERMISSIONS_END = 'REQUEST_PERMISSIONS_END',\n\n  /**\n   * This event is fired when the user opens the login popup.\n   */\n  LOGIN_START = 'LOGIN_START',\n\n  /**\n   * This event is fired when the user completes logging in, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  LOGIN_END = 'LOGIN_END',\n\n  /**\n   * This event is fired when the user opens the logout popup.\n   */\n  LOGOUT_START = 'LOGOUT_START',\n\n  /**\n   * This event is fired when the user completes logging out, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  LOGOUT_END = 'LOGOUT_END',\n\n  /**\n   * This event is fired when the user opens the get deso popup.\n   */\n  GET_FREE_DESO_START = 'GET_FREE_DESO_START',\n\n  /**\n   * This event is fired when the user completes the get deso flow, and comes\n   * AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  GET_FREE_DESO_END = 'GET_FREE_DESO_END',\n\n  /**\n   * This event is fired when the user opens the verify phone number popup.\n   */\n  VERIFY_PHONE_NUMBER_START = 'VERIFY_PHONE_NUMBER_START',\n\n  /**\n   * This event is fired when the user completes the verify phone number flow,\n   * and comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  VERIFY_PHONE_NUMBER_END = 'VERIFY_PHONE_NUMBER_END',\n\n  /**\n   * This event is fired when the consuming app switches the active user.\n   */\n  CHANGE_ACTIVE_USER = 'CHANGE_ACTIVE_USER',\n}\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>;\n  setItem: (key: string, value: string) => Promise<void>;\n  removeItem: (key: string) => Promise<void>;\n  clear: () => Promise<void>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/identity/types.ts"],"names":[],"mappings":"AA4PA,MAAM,CAAN,IAAY,mBAoFX;AApFD,WAAY,mBAAmB;IAC7B;;OAEG;IACH,8CAAuB,CAAA;IAEvB;;;;OAIG;IACH,kFAA2D,CAAA;IAE3D;;;;OAIG;IACH,8EAAuD,CAAA;IAEvD;;OAEG;IACH,gFAAyD,CAAA;IAEzD;;OAEG;IACH,8EAAuD,CAAA;IAEvD;;;OAGG;IACH,0EAAmD,CAAA;IAEnD;;OAEG;IACH,kDAA2B,CAAA;IAE3B;;;OAGG;IACH,8CAAuB,CAAA;IAEvB;;OAEG;IACH,oDAA6B,CAAA;IAE7B;;;OAGG;IACH,gDAAyB,CAAA;IAEzB;;OAEG;IACH,kEAA2C,CAAA;IAE3C;;;OAGG;IACH,8DAAuC,CAAA;IAEvC;;OAEG;IACH,8EAAuD,CAAA;IAEvD;;;OAGG;IACH,0EAAmD,CAAA;IAEnD;;OAEG;IACH,gEAAyC,CAAA;AAC3C,CAAC,EApFW,mBAAmB,KAAnB,mBAAmB,QAoF9B","sourcesContent":["import {\n  AccessGroupLimitMapItem,\n  AccessGroupMemberLimitMapItem,\n  AssociationLimitMapItem,\n  TransactionSpendingLimitResponse,\n  TransactionType,\n} from '../backend-types';\nexport type Network = 'mainnet' | 'testnet';\n\nexport interface IdentityResponse {\n  service: 'identity';\n  method: 'derive' | 'login' | 'initialize';\n  payload?: any;\n  id?: string;\n}\n\nexport interface IdentityDerivePayload {\n  derivedSeedHex?: string;\n  derivedPublicKeyBase58Check: string;\n  publicKeyBase58Check: string;\n  btcDepositAddress: string;\n  ethDepositAddress: string;\n  expirationBlock: number;\n  network: Network;\n  accessSignature: string;\n  jwt: string;\n  derivedJwt: string;\n  messagingPublicKeyBase58Check: string;\n  messagingPrivateKey: string;\n  messagingKeyName: string;\n  messagingKeySignature: string;\n  transactionSpendingLimitHex: string;\n  signedUp: boolean;\n  publicKeyAdded?: string;\n}\n\nexport interface TransactionSpendingLimitResponseOptions {\n  GlobalDESOLimit?: number;\n  TransactionCountLimitMap?: Partial<\n    Record<TransactionType, number | 'UNLIMITED'>\n  >;\n  CreatorCoinOperationLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  DAOCoinOperationLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  NFTOperationLimitMap?: {\n    [key: string]: { [key: number]: { [key: string]: number | 'UNLIMITED' } };\n  };\n  DAOCoinLimitOrderLimitMap?: {\n    [key: string]: { [key: string]: number | 'UNLIMITED' };\n  };\n  AssociationLimitMap?: (Omit<AssociationLimitMapItem, 'OpCount'> & {\n    OpCount: number | 'UNLIMITED';\n  })[];\n  AccessGroupLimitMap?: (Omit<AccessGroupLimitMapItem, 'OpCount'> & {\n    OpCount: number | 'UNLIMITED';\n  })[];\n  AccessGroupMemberLimitMap?: (Omit<\n    AccessGroupMemberLimitMapItem,\n    'OpCount'\n  > & { OpCount: number | 'UNLIMITED' })[];\n  IsUnlimited?: boolean;\n}\n\nexport type jwtAlgorithm = 'ES256K' | 'ES256';\nexport interface IdentityConfiguration {\n  /**\n   * The identity domain. Defaults to https://identity.deso.org\n   */\n  identityURI?: string;\n\n  /**\n   * The current network. If not provided, we will assume mainnet.\n   */\n  network?: Network;\n\n  /**\n   * The deso node used for any api calls (get balance, derived key authorization, etc)\n   */\n  nodeURI?: string;\n\n  /**\n   * Optional redirect URI. If provided, we do a hard redirect to the identity\n   * domain and pass data via query params back to the provided uri.\n   */\n  redirectURI?: string;\n\n  /**\n   * The default permissions and spending limits that will be presented to the user\n   * during login. If not provided, we will assume no permissions.\n   */\n  spendingLimitOptions?: TransactionSpendingLimitResponseOptions;\n\n  /**\n   * The name of the app used to authorize derived keys. Defaults to unknown.\n   */\n  appName?: string;\n\n  /**\n   * Since our keys are generated using the secp256k1 curve, the correct\n   * JWT algorithm header *should* be ES256K.\n   * See: https://www.rfc-editor.org/rfc/rfc8812.html#name-jose-algorithms-registratio\n   *\n   * HOWEVER, the backend jwt lib used by deso foundation -\n   * https://github.com/golang-jwt/jwt - (as well as many other jwt libraries)\n   * do not support ES256K. So instead, we default to the more widely supported ES256 algo,\n   * which can still work for verifying our signatures. But if a consumer of this lib is using a\n   * jwt lib that supports ES256K they can specify that here.\n   * See this github issue\n   * for more context: https://github.com/auth0/node-jsonwebtoken/issues/862\n   * If ES256K is ever supported by the backend jwt lib, we should change this.\n   */\n  jwtAlgorithm?: jwtAlgorithm;\n\n  /**\n   * An optional storage provider. If not provided, we will assume localStorage\n   * is available.\n   */\n  storageProvider?: Storage | AsyncStorage;\n\n  /**\n   * An optional function that is provided the identity url that needs to be\n   * opened. This can be used to customize how the identity url is opened. For\n   * example, if you are using react native, you might want to use the Linking\n   * API to open the url in a system browser window.\n   * @example\n   * ```ts\n   * identityPresenter: async (url) => {\n   *   const result = await WebBrowser.openAuthSessionAsync(url);\n   *   if (result.type === 'success') {\n   *     identity.handleRedirectURI(result.url);\n   *   }\n   * },\n   * ```\n   */\n  identityPresenter?: (url: string) => void;\n}\n\nexport interface APIProvider {\n  post: (url: string, data: any) => Promise<any>;\n  get: (url: string) => Promise<any>;\n}\n\nexport interface WindowProvider {\n  location: { search: string; pathname: string; href: string };\n  history: { replaceState: (state: any, title: string, url: string) => void };\n  localStorage: {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n  };\n  open: (\n    url: string,\n    title: string | undefined,\n    options: string\n  ) => Window | null;\n  addEventListener: (event: string, callback: (event: any) => void) => void;\n  removeEventListener: (event: string, callback: (event: any) => void) => void;\n}\n\nexport interface LoginOptions {\n  getFreeDeso: boolean;\n}\n\nexport type PrimaryDerivedKeyInfo = IdentityDerivePayload & {\n  transactionSpendingLimits: TransactionSpendingLimitResponse;\n  IsValid?: boolean;\n};\n\nexport type StoredUser = {\n  publicKey: string;\n  primaryDerivedKey: PrimaryDerivedKeyInfo;\n};\n\nexport interface IdentityUser {\n  accessLevel: number;\n  accessLevelHmac: string;\n  btcDepositAddress: string;\n  encryptedSeedHex: string;\n  ethDepositAddress: string;\n  derivedPublicKeyBase58Check?: string;\n  hasExtraText: boolean;\n  network: string;\n  version: number;\n}\n\nexport interface IdentityLoginPayload {\n  users: Record<string, IdentityUser>;\n  publicKeyAdded: string;\n  phoneNumberSuccess: boolean;\n  signedUp: boolean;\n}\n\nexport interface IdentityState {\n  currentUser: StoredUser | null;\n  alternateUsers: Record<string, StoredUser> | null;\n}\n\nexport interface Deferred {\n  resolve: (args: any) => void;\n  reject: (args: any) => void;\n}\n\nexport interface KeyPair {\n  seedHex: string;\n  private: Uint8Array;\n  public: Uint8Array;\n}\n\nexport interface SubscriberNotification {\n  event: NOTIFICATION_EVENTS;\n  currentUser: StoredUser | null;\n  alternateUsers: Record<string, StoredUser> | null;\n}\n\nexport interface EtherscanTransactionsByAddressResponse {\n  status: string;\n  message: string;\n  result: EtherscanTransaction[];\n}\n\nexport interface EtherscanTransaction {\n  blockNumber: string;\n  timestamp: string;\n  hash: string;\n  nonce: string;\n  blockHash: string;\n  transactionIndex: string;\n  from: string;\n  to: string;\n  value: string;\n  gas: string;\n  gasPrice: string;\n  isError: string;\n  txreceipt_status: string;\n  input: string;\n  contractAddress: string;\n  cumulativeGasUsed: string;\n  gasUsed: string;\n  confirmations: string;\n  methodId: string;\n  functionName: string;\n}\n\nexport interface AccessGroupPrivateInfo {\n  AccessGroupPublicKeyBase58Check: string;\n  AccessGroupPrivateKeyHex: string;\n  AccessGroupKeyName: string;\n}\n\nexport enum NOTIFICATION_EVENTS {\n  /**\n   * This event is fired when the consuming app initially subscribes to identity.\n   */\n  SUBSCRIBE = 'SUBSCRIBE',\n\n  /**\n   * This is an intermediate event fired AFTER the user completes an identity flow\n   * that requires a derived key authorization. This event is fired BEFORE the\n   * request to authorize the derived key is made.\n   */\n  AUTHORIZE_DERIVED_KEY_START = 'AUTHORIZE_DERIVED_KEY_START',\n\n  /**\n   * This is an intermediate event fired AFTER the user completes an identity\n   * flow that requires a derived key authorization. This event is fired AFTER\n   * the request to authorize the derived key is made.\n   */\n  AUTHORIZE_DERIVED_KEY_END = 'AUTHORIZE_DERIVED_KEY_END',\n\n  /**\n   * This event is fired if the request to authorize a derived key fails.\n   */\n  AUTHORIZE_DERIVED_KEY_FAIL = 'AUTHORIZE_DERIVED_KEY_FAIL',\n\n  /**\n   * This event is fired when the user opens the permissions approval popup.\n   */\n  REQUEST_PERMISSIONS_START = 'REQUEST_PERMISSIONS_START',\n\n  /**\n   * This event is fired when the user completes approving permissions, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  REQUEST_PERMISSIONS_END = 'REQUEST_PERMISSIONS_END',\n\n  /**\n   * This event is fired when the user opens the login popup.\n   */\n  LOGIN_START = 'LOGIN_START',\n\n  /**\n   * This event is fired when the user completes logging in, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  LOGIN_END = 'LOGIN_END',\n\n  /**\n   * This event is fired when the user opens the logout popup.\n   */\n  LOGOUT_START = 'LOGOUT_START',\n\n  /**\n   * This event is fired when the user completes logging out, and\n   * comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  LOGOUT_END = 'LOGOUT_END',\n\n  /**\n   * This event is fired when the user opens the get deso popup.\n   */\n  GET_FREE_DESO_START = 'GET_FREE_DESO_START',\n\n  /**\n   * This event is fired when the user completes the get deso flow, and comes\n   * AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  GET_FREE_DESO_END = 'GET_FREE_DESO_END',\n\n  /**\n   * This event is fired when the user opens the verify phone number popup.\n   */\n  VERIFY_PHONE_NUMBER_START = 'VERIFY_PHONE_NUMBER_START',\n\n  /**\n   * This event is fired when the user completes the verify phone number flow,\n   * and comes AFTER the intermediate AUTHORIZE_DERIVED_KEY events.\n   */\n  VERIFY_PHONE_NUMBER_END = 'VERIFY_PHONE_NUMBER_END',\n\n  /**\n   * This event is fired when the consuming app switches the active user.\n   */\n  CHANGE_ACTIVE_USER = 'CHANGE_ACTIVE_USER',\n}\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>;\n  setItem: (key: string, value: string) => Promise<void>;\n  removeItem: (key: string) => Promise<void>;\n  clear: () => Promise<void>;\n}\n"]}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1501940

increased by0.13%

Number of lines in readme file

347

increased by48.93%

Worsened metrics

Lines of code

13690

decreased by-0.09%

No dependency changes