@coinflowlabs/angular 0.0.3 → 0.0.4

package/src/lib/common/CoinflowTypes.ts

@@ -0,0 +1,403 @@
+import type {
+  Connection,
+  VersionedTransaction,
+  PublicKey,
+  Signer,
+  Transaction,
+} from '@solana/web3.js';
+
+export enum SettlementType {
+  Credits = 'Credits',
+  USDC = 'USDC',
+  Bank = 'Bank',
+}
+
+export enum MerchantStyle {
+  Rounded = 'rounded',
+  Sharp = 'sharp',
+  Pill = 'pill',
+}
+
+export type MerchantTheme = {
+  primary?: string;
+  background?: string;
+  backgroundAccent?: string;
+  backgroundAccent2?: string;
+  textColor?: string;
+  textColorAccent?: string;
+  textColorAction?: string;
+  font?: string;
+  style?: MerchantStyle;
+};
+
+export interface CustomerInfo {
+  name?: string;
+  verificationId?: string;
+  displayName?: string;
+  address?: string;
+  city?: string;
+  state?: string;
+  zip?: string;
+  country?: string;
+  ip?: string;
+  lat?: string;
+  lng?: string;
+}
+
+/** Coinflow Types **/
+export type CoinflowBlockchain = 'solana' | 'near' | 'eth' | 'polygon' | 'base';
+export type CoinflowEnvs = 'prod' | 'staging' | 'sandbox' | 'local';
+
+export interface CoinflowTypes {
+  merchantId: string;
+  env?: CoinflowEnvs;
+  loaderBackground?: string;
+  blockchain: CoinflowBlockchain;
+  handleHeightChange?: (height: string) => void;
+  theme?: MerchantTheme;
+}
+
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+export type OnSuccessMethod = (params: string) => void | Promise<void>;
+
+/** Wallets **/
+export interface SolanaWallet {
+  publicKey: PublicKey | null;
+  signTransaction?: <T extends Transaction | VersionedTransaction>(
+    transaction: T
+  ) => Promise<T>;
+  sendTransaction: <T extends Transaction | VersionedTransaction>(
+    transaction: T
+  ) => Promise<string>;
+  signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+}
+
+export interface NearWallet {
+  accountId: string;
+  signAndSendTransaction: (transaction: unknown) => Promise<{
+    transaction: {hash: string};
+  }>;
+}
+
+type AccessList = Array<{address: string; storageKeys: Array<string>}>;
+type AccessListish =
+  | AccessList
+  | Array<[string, Array<string>]>
+  | Record<string, Array<string>>;
+
+export type EthWallet = {
+  address: string | null | undefined;
+  sendTransaction: (transaction: {
+    to: string;
+    from?: string;
+    nonce?: Bytes | bigint | string | number;
+
+    gasLimit?: Bytes | bigint | string | number;
+    gasPrice?: Bytes | bigint | string | number;
+
+    data?: BytesLike;
+    value?: Bytes | bigint | string | number;
+    chainId?: number;
+
+    type?: number;
+    accessList?: AccessListish;
+
+    maxPriorityFeePerGas?: Bytes | bigint | string | number;
+    maxFeePerGas?: Bytes | bigint | string | number;
+
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+  }) => Promise<{hash: string}>;
+  signMessage: (message: string) => Promise<string>;
+};
+
+/** History **/
+export interface CoinflowSolanaHistoryProps extends CoinflowTypes {
+  wallet: SolanaWallet;
+  connection: Connection;
+  blockchain: 'solana';
+}
+
+export interface CoinflowNearHistoryProps extends CoinflowTypes {
+  wallet: NearWallet;
+  blockchain: 'near';
+}
+
+export interface CoinflowEvmHistoryProps extends CoinflowTypes {
+  wallet: EthWallet;
+}
+
+export interface CoinflowEthHistoryProps extends CoinflowEvmHistoryProps {
+  blockchain: 'eth';
+}
+
+export interface CoinflowPolygonHistoryProps extends CoinflowEvmHistoryProps {
+  blockchain: 'polygon';
+}
+
+export interface CoinflowBaseHistoryProps extends CoinflowEvmHistoryProps {
+  blockchain: 'base';
+}
+
+export type CoinflowHistoryProps =
+  | CoinflowSolanaHistoryProps
+  | CoinflowNearHistoryProps
+  | CoinflowPolygonHistoryProps
+  | CoinflowEthHistoryProps
+  | CoinflowBaseHistoryProps;
+
+/** Transactions **/
+
+export type NearFtTransferCallAction = {
+  methodName: 'ft_transfer_call';
+  args: object;
+  gas: string;
+  deposit: string;
+};
+
+type Bytes = ArrayLike<number>;
+type BytesLike = Bytes | string;
+
+/** Purchase **/
+
+export type ChargebackProtectionData = ChargebackProtectionItem[];
+
+export interface ChargebackProtectionItem {
+  /**
+   * The name of the product
+   */
+  productName: string;
+  /**
+   * The product type. Possible values include: inGameProduct, gameOfSkill, dataStorage, computingResources, sportsTicket, eSportsTicket, musicTicket, conferenceTicket, virtualSportsTicket, virtualESportsTicket, virtualMusicTicket, virtualConferenceTicket, alcohol, DLC, subscription, fundACause, realEstate, computingContract, digitalArt, topUp
+   */
+  productType:
+    | 'inGameProduct'
+    | 'gameOfSkill'
+    | 'dataStorage'
+    | 'computingResources'
+    | 'sportsTicket'
+    | 'eSportsTicket'
+    | 'musicTicket'
+    | 'conferenceTicket'
+    | 'virtualSportsTicket'
+    | 'virtualESportsTicket'
+    | 'virtualMusicTicket'
+    | 'virtualConferenceTicket'
+    | 'alcohol'
+    | 'DLC'
+    | 'subscription'
+    | 'fundACause'
+    | 'realEstate'
+    | 'computingContract'
+    | 'digitalArt'
+    | 'topUp'
+    | 'ownershipContract';
+  /**
+   * The item's list price
+   */
+  /**
+   * The number of units sold
+   */
+  quantity: number;
+  /**
+   * Any additional data that the store can provide on the product, e.g. description, link to image, etc.
+   */
+  rawProductData?: {[key: string]: any};
+}
+
+export interface CoinflowCommonPurchaseProps extends CoinflowTypes {
+  amount?: number;
+  onSuccess?: OnSuccessMethod;
+  webhookInfo?: object;
+  email?: string;
+  chargebackProtectionData?: ChargebackProtectionData;
+  planCode?: string;
+  disableApplePay?: boolean;
+  disableGooglePay?: boolean;
+  customerInfo?: CustomerInfo;
+  settlementType?: SettlementType;
+  authOnly?: boolean;
+  deviceId?: string;
+}
+
+export interface CoinflowSolanaPurchaseProps
+  extends CoinflowCommonPurchaseProps {
+  wallet: SolanaWallet;
+  transaction?: Transaction | VersionedTransaction;
+  partialSigners?: Signer[];
+  debugTx?: boolean;
+  connection: Connection;
+  blockchain: 'solana';
+  token?: PublicKey | string;
+  supportsVersionedTransactions?: boolean;
+  rent?: {lamports: string | number};
+  nativeSolToConvert?: {lamports: string | number};
+}
+
+export interface CoinflowNearPurchaseProps extends CoinflowCommonPurchaseProps {
+  wallet: NearWallet;
+  blockchain: 'near';
+  action?: NearFtTransferCallAction;
+  nearDeposit?: string;
+}
+
+export interface CoinflowEvmPurchaseProps extends CoinflowCommonPurchaseProps {
+  transaction?: EvmTransactionData;
+  token?: string;
+  wallet: EthWallet;
+}
+
+export interface CoinflowPolygonPurchaseProps extends CoinflowEvmPurchaseProps {
+  blockchain: 'polygon';
+}
+
+export interface CoinflowEthPurchaseProps extends CoinflowEvmPurchaseProps {
+  blockchain: 'eth';
+}
+
+export interface CoinflowBasePurchaseProps extends CoinflowEvmPurchaseProps {
+  blockchain: 'base';
+}
+
+export type CoinflowPurchaseProps =
+  | CoinflowSolanaPurchaseProps
+  | CoinflowNearPurchaseProps
+  | CoinflowPolygonPurchaseProps
+  | CoinflowEthPurchaseProps
+  | CoinflowBasePurchaseProps;
+
+/** Withdraw **/
+
+export interface CoinflowCommonWithdrawProps extends CoinflowTypes {
+  onSuccess?: OnSuccessMethod;
+  tokens?: string[];
+  lockDefaultToken?: boolean;
+  amount?: number;
+  email?: string;
+  bankAccountLinkRedirect?: string;
+  additionalWallets?: {
+    wallet: string;
+    blockchain: 'solana' | 'eth' | 'near' | 'polygon';
+  }[];
+  supportsVersionedTransactions?: boolean;
+  lockAmount?: boolean;
+  transactionSigner?: string;
+}
+
+export interface CoinflowSolanaWithdrawProps
+  extends CoinflowCommonWithdrawProps {
+  wallet: SolanaWallet;
+  connection: Connection;
+  blockchain: 'solana';
+}
+
+export interface CoinflowNearWithdrawProps extends CoinflowCommonWithdrawProps {
+  wallet: NearWallet;
+  blockchain: 'near';
+}
+
+export interface CoinflowEvmWithdrawProps extends CoinflowCommonWithdrawProps {
+  wallet: EthWallet;
+  usePermit?: boolean;
+}
+
+export interface CoinflowEthWithdrawProps extends CoinflowEvmWithdrawProps {
+  blockchain: 'eth';
+  usePermit?: boolean;
+}
+
+export interface CoinflowPolygonWithdrawProps extends CoinflowEvmWithdrawProps {
+  blockchain: 'polygon';
+}
+
+export interface CoinflowBaseWithdrawProps extends CoinflowEvmWithdrawProps {
+  blockchain: 'base';
+}
+
+export type CoinflowWithdrawProps =
+  | CoinflowSolanaWithdrawProps
+  | CoinflowNearWithdrawProps
+  | CoinflowEthWithdrawProps
+  | CoinflowPolygonWithdrawProps
+  | CoinflowBaseWithdrawProps;
+
+export interface CommonEvmRedeem {
+  waitForHash?: boolean;
+}
+
+export interface NormalRedeem extends CommonEvmRedeem {
+  transaction: {to: string; data: string};
+}
+
+export interface KnownTokenIdRedeem extends NormalRedeem {
+  nftContract: string;
+  nftId: string;
+}
+
+export interface SafeMintRedeem extends NormalRedeem {
+  type: 'safeMint';
+  nftContract?: string;
+}
+
+export interface ReturnedTokenIdRedeem extends NormalRedeem {
+  type: 'returned';
+  nftContract?: string;
+}
+
+type ReservoirNftIdItem = Omit<KnownTokenIdRedeem, keyof NormalRedeem>;
+interface ReservoirOrderIdItem {
+  orderId: string;
+}
+type ReservoirItem = ReservoirNftIdItem | ReservoirOrderIdItem;
+type ReservoirItems = ReservoirItem | ReservoirItem[];
+
+export interface ReservoirRedeem extends CommonEvmRedeem {
+  type: 'reservoir';
+  items: ReservoirItems;
+}
+
+export type EvmTransactionData =
+  | SafeMintRedeem
+  | ReturnedTokenIdRedeem
+  | ReservoirRedeem
+  | KnownTokenIdRedeem
+  | NormalRedeem;
+
+export interface CoinflowIFrameProps
+  extends Omit<CoinflowTypes, 'merchantId'>,
+    Pick<
+      CoinflowCommonPurchaseProps,
+      | 'chargebackProtectionData'
+      | 'webhookInfo'
+      | 'amount'
+      | 'customerInfo'
+      | 'settlementType'
+      | 'email'
+      | 'planCode'
+      | 'deviceId'
+    >,
+    Pick<
+      CoinflowCommonWithdrawProps,
+      | 'bankAccountLinkRedirect'
+      | 'additionalWallets'
+      | 'transactionSigner'
+      | 'lockAmount'
+      | 'lockDefaultToken'
+    >,
+    Pick<CoinflowEvmPurchaseProps, 'authOnly'>,
+    Pick<CoinflowSolanaPurchaseProps, 'rent' | 'nativeSolToConvert' | 'token'> {
+  walletPubkey: string | null | undefined;
+  route: string;
+  routePrefix?: string;
+  transaction?: string;
+  tokens?: string[] | PublicKey[];
+  supportsVersionedTransactions?: boolean;
+  nearDeposit?: string;
+  merchantCss?: string;
+  color?: 'white' | 'black';
+  disableApplePay?: boolean;
+  disableGooglePay?: boolean;
+  theme?: MerchantTheme;
+  usePermit?: boolean;
+}

package/src/lib/common/CoinflowUtils.ts

@@ -0,0 +1,269 @@
+import {
+  CoinflowBlockchain,
+  CoinflowEnvs,
+  CoinflowIFrameProps,
+  CoinflowPurchaseProps,
+} from './CoinflowTypes';
+import * as web3 from '@solana/web3.js';
+import * as base58 from 'bs58';
+
+export class CoinflowUtils {
+  env: CoinflowEnvs;
+  url: string;
+
+  constructor(env?: CoinflowEnvs) {
+    this.env = env ?? 'prod';
+    if (this.env === 'prod') this.url = 'https://api.coinflow.cash';
+    else if (this.env === 'local') this.url = 'http://localhost:5000';
+    else this.url = `https://api-${this.env}.coinflow.cash`;
+  }
+
+  async getNSurePartnerId(merchantId: string): Promise<string | undefined> {
+    return fetch(this.url + `/merchant/view/${merchantId}`)
+      .then(response => response.json())
+      .then(
+        (json: {
+          nSurePartnerId: string | undefined;
+          nSureSettings: {nSurePartnerId: string | undefined};
+        }) => json.nSureSettings?.nSurePartnerId || json.nSurePartnerId
+      )
+      .catch(e => {
+        console.error(e);
+        return undefined;
+      });
+  }
+
+  async getCreditBalance(
+    publicKey: string,
+    merchantId: string,
+    blockchain: 'solana' | 'near'
+  ): Promise<{cents: number}> {
+    const response = await fetch(
+      this.url + `/api/customer/balances/${merchantId}`,
+      {
+        method: 'GET',
+        headers: {
+          'x-coinflow-auth-wallet': publicKey,
+          'x-coinflow-auth-blockchain': blockchain,
+        },
+      }
+    );
+    const {credits} = await response.json();
+    return credits;
+  }
+
+  static getCoinflowBaseUrl(env?: CoinflowEnvs): string {
+    if (!env || env === 'prod') return 'https://coinflow.cash';
+    if (env === 'local') return 'http://localhost:3000';
+
+    return `https://${env}.coinflow.cash`;
+  }
+
+  static getCoinflowApiUrl(env?: CoinflowEnvs): string {
+    if (!env || env === 'prod') return 'https://api.coinflow.cash';
+    if (env === 'local') return 'http://localhost:5000';
+
+    return `https://api-${env}.coinflow.cash`;
+  }
+
+  static getCoinflowUrl({
+    walletPubkey,
+    route,
+    routePrefix,
+    env,
+    amount,
+    transaction,
+    blockchain,
+    supportsVersionedTransactions,
+    webhookInfo,
+    email,
+    loaderBackground,
+    handleHeightChange,
+    bankAccountLinkRedirect,
+    additionalWallets,
+    nearDeposit,
+    chargebackProtectionData,
+    merchantCss,
+    color,
+    rent,
+    lockDefaultToken,
+    token,
+    tokens,
+    planCode,
+    disableApplePay,
+    disableGooglePay,
+    customerInfo,
+    settlementType,
+    lockAmount,
+    nativeSolToConvert,
+    theme,
+    usePermit,
+    transactionSigner,
+    authOnly,
+    deviceId,
+  }: CoinflowIFrameProps): string {
+    const prefix = routePrefix
+      ? `/${routePrefix}/${blockchain}`
+      : `/${blockchain}`;
+    const url = new URL(prefix + route, CoinflowUtils.getCoinflowBaseUrl(env));
+    url.searchParams.append('pubkey', walletPubkey!);
+
+    if (transaction) {
+      url.searchParams.append('transaction', transaction);
+    }
+    if (amount) {
+      url.searchParams.append('amount', amount.toString());
+    }
+
+    if (supportsVersionedTransactions) {
+      url.searchParams.append('supportsVersionedTransactions', 'true');
+    }
+
+    if (webhookInfo) {
+      url.searchParams.append(
+        'webhookInfo',
+        Buffer.from(JSON.stringify(webhookInfo)).toString('base64')
+      );
+    }
+
+    if (theme) {
+      url.searchParams.append(
+        'theme',
+        Buffer.from(JSON.stringify(theme)).toString('base64')
+      );
+    }
+
+    if (customerInfo) {
+      url.searchParams.append(
+        'customerInfo',
+        Buffer.from(JSON.stringify(customerInfo)).toString('base64')
+      );
+    }
+
+    if (email) {
+      url.searchParams.append('email', email);
+    }
+
+    if (token) {
+      url.searchParams.append('token', token.toString());
+    }
+
+    if (tokens) {
+      url.searchParams.append('tokens', tokens.toString());
+    }
+
+    if (loaderBackground) {
+      url.searchParams.append('loaderBackground', loaderBackground);
+    }
+
+    if (handleHeightChange) {
+      url.searchParams.append('useHeightChange', 'true');
+    }
+
+    if (bankAccountLinkRedirect) {
+      url.searchParams.append(
+        'bankAccountLinkRedirect',
+        bankAccountLinkRedirect
+      );
+    }
+
+    if (additionalWallets)
+      url.searchParams.append(
+        'additionalWallets',
+        JSON.stringify(additionalWallets)
+      );
+
+    if (nearDeposit) url.searchParams.append('nearDeposit', nearDeposit);
+
+    if (chargebackProtectionData)
+      url.searchParams.append(
+        'chargebackProtectionData',
+        JSON.stringify(chargebackProtectionData)
+      );
+    if (deviceId) {
+      url.searchParams.append('deviceId', deviceId);
+    } else {
+      if (typeof window !== 'undefined') {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const deviceId = window?.nSureSDK?.getDeviceId();
+        if (deviceId) url.searchParams.append('deviceId', deviceId);
+      }
+    }
+
+    if (merchantCss) url.searchParams.append('merchantCss', merchantCss);
+    if (color) url.searchParams.append('color', color);
+    if (rent) url.searchParams.append('rent', rent.lamports.toString());
+    if (nativeSolToConvert)
+      url.searchParams.append(
+        'nativeSolToConvert',
+        nativeSolToConvert.lamports.toString()
+      );
+    if (lockDefaultToken) url.searchParams.append('lockDefaultToken', 'true');
+    if (planCode) url.searchParams.append('planCode', planCode);
+
+    if (disableApplePay) url.searchParams.append('disableApplePay', 'true');
+    if (disableGooglePay) url.searchParams.append('disableGooglePay', 'true');
+    if (settlementType)
+      url.searchParams.append('settlementType', settlementType);
+
+    if (lockAmount) url.searchParams.append('lockAmount', 'true');
+
+    if (usePermit === false) url.searchParams.append('usePermit', 'false');
+    if (transactionSigner)
+      url.searchParams.append('transactionSigner', transactionSigner);
+    if (authOnly === true) url.searchParams.append('authOnly', 'true');
+
+    return url.toString();
+  }
+
+  static getTransaction(props: CoinflowPurchaseProps): string | undefined {
+    if ('transaction' in props && props.transaction !== undefined) {
+      const {transaction} = props;
+      if (web3 && transaction instanceof web3.Transaction) {
+        if (!base58) throw new Error('bs58 dependency is required for Solana');
+        return base58.encode(
+          transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+          })
+        );
+      }
+
+      if (web3 && transaction instanceof web3.VersionedTransaction) {
+        if (!base58) throw new Error('bs58 dependency is required for Solana');
+        return base58.encode(transaction.serialize());
+      }
+
+      return btoa(JSON.stringify(transaction));
+    }
+
+    if ('action' in props && props.action !== undefined) {
+      return btoa(JSON.stringify(props.action));
+    }
+
+    return undefined;
+  }
+
+  static byBlockchain<T>(
+    blockchain: CoinflowBlockchain,
+    args: {solana: T; near: T; eth?: T; polygon: T; base: T}
+  ): T {
+    switch (blockchain) {
+      case 'solana':
+        return args.solana;
+      case 'near':
+        return args.near;
+      case 'polygon':
+        return args.polygon;
+      case 'eth':
+        if (args.eth === undefined)
+          throw new Error('blockchain not supported for this operation!');
+        return args.eth;
+      case 'base':
+        return args.base;
+      default:
+        throw new Error('blockchain not supported!');
+    }
+  }
+}

package/{public-api.d.ts → src/public-api.ts}

@@ -1,3 +1,7 @@
+/*
+ * Public API Surface of coinflowlabs
+ */
+
 export * from './lib/coinflow-iframe.component';
 export * from './lib/coinflow-purchase.component';
 export * from './lib/coinflow-purchase-history.component';

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}