React Native (JavaScript) - Auth

pod "Thresh", '1.4.11'
pod "ParticleMPCCore", '1.4.11'
pod "ParticleAuthCore", '1.4.11'
pod "AuthCoreAdapter", '1.4.11'

pod 'ParticleNetworkBase', '1.4.10'
pod 'ConnectCommon',  '0.2.24'

pod 'SwiftyUserDefaults', :git ='https://github.com/SunZhiC/SwiftyUserDefaults.git', :branch ='master'
pod 'SkeletonView', :git ='https://github.com/SunZhiC/SkeletonView.git', :branch ='main'


post_install do |installer|
installer.pods_project.targets.each do |target|
  target.build_configurations.each do |config|
  config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
    end
  end
 end

import * as particleAuthCore from "@particle-network/rn-auth-core";
import * as particleBase from "@particle-network/rn-base";

import * as particleBase from '@particle-network/rn-base';
import * as particleAuthCore from '@particle-network/rn-auth-core';

const chainInfo = Ethereum;
const env = Env.Production;
particleBase.init(chainInfo, env);
particleAuthCore.init();

import type { LoginType, SupportAuthType } from '@particle-network/rn-base'
import * as particleAuthCore from '@particle-network/rn-auth-core';

// Google or other social login
const userInfo = await particleAuthCore.connect(LoginType.Google, null, [], SocialLoginPrompt.SelectAccount);

// Email or phone login, facilitated through Particle's UI
const userInfo = await particleAuthCore.connect(LoginType.Email, null, supportAuthTypes, SocialLoginPrompt.SelectAccount, {
        projectName: "React Native Example",
        description: "Welcome to login",
        imagePath: base64Img
      });

// Custom authentication via JWT
const userInfo = await particleAuthCore.connect(LoginType.JWT, jwt);

// Configuration of a custom email or phone login page, programmatically driving verification codes
const isSuccess = await particleAuthCore.sendEmailCode("user@example.com");
const isSuccess = await particleAuthCore.sendPhoneCode("11234567890");

// After a code is sent, the user should enter it within your UI, upon which you can use it for connection
const userInfo = await ParticleAuthCore.connectWithCode(null, "user@example.com", code);
const userInfo = await ParticleAuthCore.connectWithCode("+11234567890", null, this.state.code);

const status = await particleAuthCore.disconnect();

const result = await particleAuthCore.isConnected()

import {evm, solana} from '@particle-network/rn-auth-core';

const evmAddress = await evm.getAddress();
const solanaAddress = await solana.getAddress();

const userInfo = await particleAuthCore.getUserInfo();

const message = "GM, Particle!"
const result = await evm.personalSign(message);

const result = await solana.signMessage(message);

const signature = await solana.signTransaction(transaction);

const signatures = await solana.signAllTransactions(transactions);

const txHash = await evm.sendTransaction(transaction);

const txHash = await solana.signAndSendTransaction(transaction);

 const signature = await evm.signTypedData(typedData);

await particleBase.setChainInfo(Ethereum);

await particleAuthCore.switchChain(Ethereum);

const chainInfo = await particleBase.getChainInfo();

particleBase.setSecurityAccountConfig(new SecurityAccountConfig(0, 0));

const status = await particleAuthCore.openAccountAndSecurity();

const hasMasterPassword = await particleAuthCore.hasMasterPassword();
const hasPaymentPassword = await particleAuthCore.hasPaymentPassword();
const isChangedMasterPassword = await particleAuthCore.changeMasterPassword();

// This is the default setting
particleBase.setAppearance(Appearance.System);
// Dark mode
particleBase.setAppearance(Appearance.Dark);
// Light mode
particleBase.setAppearance(Appearance.Dark);

particleBase.setLanguage(Language.en);

const language = particleBase.getLanguage();

// Enable blind signing
particleAuthCore.setBlindEnable(true);
// Retrieve state of the blind signing feature; whether or not it's enabled
const result = await particleAuthCore.getBlindEnable();

const isoCodeList = ['US', 'CA', 'GB'];
particleBase.setUnsupportCountries(isoCodeList);

const from = "Sender address";
const contractAddress = "The contract address";
const methodName =  "Your method name"; // This is your contract method name, like balanceOf, mint.
const params: string[] = ["0x1"]; // This is the method params, each parameter requires a hexadecimal string.


// Contract ABI (JSON string)
// For example,
// [{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]
const abiJsonString = "";
const transaction = await EvmService.writeContract(from, BigNumber(0), contractAddress, methodName, params, abiJsonString, GasFeeLevel.high);

const from = "Sender address";
const contractAddress = "The contract address";
const methodName = "Your method name";
const params: string[] = [];

// Contract ABI (JSON string)
// For example,
// [{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]
const abiJsonString = "";

const result = await EvmService.readContract(from, BigNumber(0), contractAddress, methodName, params, abiJsonString);

const from = "Sender address";
const data = "Contract data"
const value = BigNumber(10000);
const to = "The receiver address or contract address";
const transaction = await EvmService.createTransaction(from, data, value, to, GasFeeLevel.high);

const from = "Sender address";
const data = "Contract data"
const value = BigNumber(10000);
const to = "The receiver address or contract address";

const valueHex = '0x' + value.toString(16);
const gasLimit = await EvmService.estimateGas(from, to, valueHex, data);

const gasFeesResult = await EvmService.suggestedGasFees();

const result = await EvmService.getTokensAndNFTs(publicAddress, []);
const result = await EvmService.getTokens(publicAddress, []);
const result = await EvmService.getNFTs(publicAddress, []);

const result = await EvmService.getTransactionsByAddress(publicAddress);

const result = await EvmService.getPrice(tokenAddresses, currencies);

const result = await EvmService.rpc(method, params);

final result = await SolanaService.getTokensAndNFTs(publicAddress, true);

const result = await SolanaService.getPrice(tokenAddresses, currencies);

const result = await SolanaService.getTransactionsByAddress(address);

const result = await SolanaService.getTokenByTokenAddresses(address, tokenAddresses);

const result = await SolanaService.rpc(method, params);