stackswap-front-api-test-02 0.10.1

package/src/stackswap/manager/token.manager.ts

@@ -0,0 +1,177 @@
+import {
+  callReadOnlyFunction, contractPrincipalCV,
+  cvToValue,
+  FungibleConditionCode, noneCV,
+  standardPrincipalCV,
+  uintCV
+} from "@stacks/transactions";
+import axios from "axios";
+import {openContractCall} from "@stacks/connect";
+import {StackswapAPI} from "../../index";
+import {getPostConditionFromAsset, getReadOptions, getWriteOptions, parseAddressToCV} from "../util";
+
+export enum TokenType {
+  VERIFIED = 1,
+  COMMUNITY = 2,
+}
+
+export enum BaseToken {
+  STX,
+  STSW,
+  vSTSW,
+  lBTC,
+  NULL,
+}
+
+export class Token {
+  name: string;
+  decimal : number;
+  icon : string;
+  addr : string;
+  symbol : string;
+  // private tokenManager: TokenManager;
+
+  constructor(name: string, decimal: number, icon: string, addr: string, symbol: string) {
+    this.name = name;
+    this.decimal = decimal;
+    this.icon = icon;
+    this.addr = addr;
+    this.symbol = symbol;
+    // this.tokenManager = tokenManager
+  }
+
+  toString() : string{
+    return '' + {name: this.name, decimal: this.decimal, icon: this.icon, addr: this.addr, symbol: this.symbol};
+  }
+
+  static parseTokenFromJson(data: any) : Token{
+    return new Token(data.name, data.decimal, data.icon, data.addr, data.symbol);
+  }
+  static parseTokenFromJsonList(datas: any) : Token[]{
+    const temp_list : Token[] = [];
+    for (const data of datas) {
+      temp_list.push(Token.parseTokenFromJson(data));
+    }
+    return temp_list;
+  }
+  static getBaseTokens(stackswap: StackswapAPI, baseToken : BaseToken) : Token{
+    switch (baseToken) {
+      case BaseToken.STX:
+        return Token.parseTokenFromJson(stackswap.config.BASE_WSTX_DATA());
+      case BaseToken.STSW:
+        return Token.parseTokenFromJson(stackswap.config.BASE_STSW_DATA());
+      case BaseToken.vSTSW:
+        return Token.parseTokenFromJson(stackswap.config.BASE_vSTSW_DATA());
+      case BaseToken.lBTC:
+        return Token.parseTokenFromJson(stackswap.config.BASE_LBTC_DATA());
+      case BaseToken.NULL:
+        return Token.parseTokenFromJson(stackswap.config.BASE_NULL_TOKEN_DATA());
+    }
+  }
+}
+
+export class TokenManager {
+  stackswap: StackswapAPI;
+
+  constructor(stackswap: StackswapAPI) {
+    this.stackswap = stackswap;
+  }
+
+  async getTokenLists(type: TokenType = TokenType.VERIFIED) : Promise<Token[]>{
+    switch (type) {
+      case TokenType.COMMUNITY:
+        const url1 = this.stackswap.config.STACKS_BACKEND_URL() + '/stacks/communitytokens/' + this.stackswap.config.STACKS_BACKEND_PARAM();
+        const res1 = await axios.get ( url1, {
+          timeout: 30000, // 해당시간안에 응답이 오지않는다면 에러처리된다.
+        });
+          return Token.parseTokenFromJsonList(res1.data);
+      case TokenType.VERIFIED:
+        const url2 = this.stackswap.config.STACKS_BACKEND_URL() + '/stacks/tokens/' + this.stackswap.config.STACKS_BACKEND_PARAM();
+        const res2 = await axios.get ( url2, {
+          timeout: 30000, // 해당시간안에 응답이 오지않는다면 에러처리된다.
+        });
+        return Token.parseTokenFromJsonList(res2.data);
+    }
+  }
+
+  async transferSTSW( toAddr: string, amount: string, callback : any = null){
+
+    // // console.log({amount});
+    const post_condition = [await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), this.stackswap.config.BASE_STSW_DATA().addr, amount, FungibleConditionCode.Equal)];
+    const function_option : any =  getWriteOptions(this.stackswap, this.stackswap.config.BASE_STSW_DATA().addr, 'transfer', [
+      uintCV(amount), standardPrincipalCV(this.stackswap.getSenderAddress()), contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), toAddr), noneCV()
+    ], post_condition, callback);
+    await openContractCall(function_option);
+  }
+
+  async getTokenData( token_addr: string) : Promise<Token | null> {
+    // // console.log('finding '+ tokenstr);
+    try {
+      const name_result = await callReadOnlyFunction( getReadOptions(this.stackswap, token_addr, 'get-name', []));
+      // // console.log(cvToValue(name_result));
+      let token_name = cvToValue(name_result).value;
+
+      const symbol_result = await callReadOnlyFunction( getReadOptions(this.stackswap, token_addr, 'get-symbol', []));
+      const token_symbol = cvToValue(symbol_result).value;
+
+      const decimal_result = await callReadOnlyFunction( getReadOptions(this.stackswap, token_addr, 'get-decimals', []));
+      const token_decimal = Number(cvToValue(decimal_result).value);
+
+      const uri_result = await callReadOnlyFunction( getReadOptions(this.stackswap, token_addr, 'get-token-uri', []));
+      const token_uri = cvToValue(uri_result).value.value;
+      // console.log('uri', cvToValue(uri_result));
+      // console.log('uri v v', cvToValue(uri_result).value.value);
+      let token_icon = 'https://app.stackswap.org/icon/blank.svg';
+      try {
+        const uri_result = await axios.get(token_uri);
+        // console.log(uri_result);
+        // console.log(uri_result.data);
+        // console.log(uri_result.data.properties);
+        if(token_icon)
+        try {
+          if (uri_result.data.image)
+            token_icon = uri_result.data.image;
+        } catch (e) {
+          // // console.log('no img file');
+        }
+        try {
+          if (uri_result.data.vector)
+            token_icon = uri_result.data.vector;
+        } catch (e) {
+          // // console.log('no svg file');
+        }
+        try {
+          if (uri_result.data.properties.image.description)
+            token_icon = uri_result.data.properties.image.description;
+        } catch (e) {
+          // // console.log('no img file');
+        }
+        try {
+          if (uri_result.data.properties.vector.description)
+            token_icon = uri_result.data.properties.vector.description;
+        } catch (e) {
+          // // console.log('no svg file');
+        }
+      } catch (e) {
+        // // console.log(e);
+      }
+      if (token_name === 'wSTX') {token_name = 'STX'; }
+      return new Token(token_name, token_decimal, token_icon, token_addr, token_symbol);
+    } catch (e) {
+      // console.log(e);
+      return null;
+    }
+  }
+
+  async getBalanceOf( token: Token, address: string) : Promise<string> {
+    // // console.log("getBalance", token)
+    const pair_details_options : any = getReadOptions(this.stackswap, token.addr, 'get-balance',
+      [parseAddressToCV(address) ]);
+    try {
+      const result = await callReadOnlyFunction(pair_details_options);
+      return cvToValue(result).value;
+    } catch (e) {
+      return '0';
+    }
+  }
+}

package/src/stackswap/util.ts

@@ -0,0 +1,275 @@
+import BigNumber from 'bignumber.js';
+
+import {
+    AnchorMode,
+    ClarityValue,
+    contractPrincipalCV, createFungiblePostCondition, createSTXPostCondition,
+    FungibleConditionCode,
+    PostConditionMode,
+    standardPrincipalCV
+} from '@stacks/transactions';
+import axios from 'axios';
+import {StackswapAPI} from "../index";
+import {LiquidityPool} from "./manager/pool.manager";
+
+export function parseAddressToCV(addr: string){
+    if (addr.includes('.')) {
+        const [address, contractName] = addr.split('.');
+        return contractPrincipalCV(address, contractName);
+    } else {
+        return standardPrincipalCV(addr);
+    }
+}
+
+export function getReadOptions(stackswap: StackswapAPI, contractName: string, functionName: string, functionArgs: ClarityValue[]) : any {
+    if (contractName.includes('.')){
+        const parsedAddress = contractName.split('.');
+        return {
+            contractAddress: parsedAddress[0],
+            contractName: parsedAddress[1],
+            functionName,
+            functionArgs,
+            network: stackswap.network,
+            senderAddress: stackswap.getSenderAddress(),
+        };
+    } else {
+        return {
+            contractAddress: stackswap.config.STACKSWAP_ADDRESS(),
+            contractName,
+            functionName,
+            functionArgs,
+            network: stackswap.network,
+            senderAddress: stackswap.getSenderAddress(),
+        };
+    }
+}
+
+
+
+export function getWriteOptions(stackswap: StackswapAPI, contractName: string, functionName: string, functionArgs: any, postConditions: any = [], callback: any = null, conditionMode: boolean = false) {
+    if ( contractName.includes('.')){
+        const parsedAddress = contractName.split('.');
+        return  {
+            contractAddress: parsedAddress[0],
+            contractName: parsedAddress[1],
+            functionName,
+            functionArgs,
+            network: stackswap.network,
+            senderAddress: stackswap.getSenderAddress(),
+            postConditionMode: conditionMode? PostConditionMode.Allow: PostConditionMode.Deny,
+            postConditions,
+            appDetails : {
+                name: 'Stackswap',
+                icon: window.location.origin + '/public/favicon.ico',
+            },
+            anchorMode: AnchorMode.Any, // speedup
+            sponsored: false,
+            onFinish : (data: any) => {
+                // console.log(data);
+                try {
+                    callback(null, data);
+                } catch (e) {
+                    callback(e, null);
+                    // console.log(e);
+                }
+            },
+            onCancel : () => {
+                try{
+                    callback('canceled', null);
+                } catch (e) {
+                    callback(e, null);
+                }
+            },
+        };
+    } else {
+        return  {
+            contractAddress: stackswap.config.STACKSWAP_ADDRESS(),
+            contractName,
+            functionName,
+            functionArgs,
+            network: stackswap.network,
+            senderAddress: stackswap.getSenderAddress(),
+            postConditionMode: conditionMode? PostConditionMode.Allow: PostConditionMode.Deny,
+            postConditions,
+            appDetails : {
+                name: 'Stackswap',
+                icon: window.location.origin + '/public/favicon.ico',
+            },
+            anchorMode: AnchorMode.Any, // speedup
+            sponsored: false,
+            onFinish : (data: any) => {
+                // console.log(data);
+                try {
+                    callback(null, data);
+                } catch (e) {
+                    callback(e, null);
+                    // console.log(e);
+                }
+            },
+            onCancel : () => {
+                try{
+                    callback('canceled', null);
+                } catch (e) {
+                    callback(e, null);
+                }
+            },
+        };
+    }
+
+}
+
+async function getFTAsset(stackswap: StackswapAPI, tokenStr: string) {
+    // console.log(tokenStr);
+    const token_addr = tokenStr.split('.');
+    const url = stackswap.config.STACKS_API_URL() + '/v2/contracts/interface/' + token_addr[0] + '/' + token_addr[1];
+    const result = await axios.get(url);
+    // console.log(tokenStr,result);
+    if (result.data.fungible_tokens.length === 1) {
+        // console.log(tokenStr+'::'+result.data.fungible_tokens[0].name);
+        return tokenStr + '::' + result.data.fungible_tokens[0].name;
+    } else if (result.data.fungible_tokens.length === 0) {
+        return 'wstx';
+    } else {
+        // TODO one contract with more than one ft
+        // console.log(tokenStr+'::'+result.data.fungible_tokens[0].name);
+        return tokenStr + '::' + result.data.fungible_tokens[0].name;
+    }
+}
+
+export async function getPostConditionFromAsset(stackswap: StackswapAPI, account: string, tokenStr: string, tokenAmount: any, condition: FungibleConditionCode) {
+    const assetString = await getFTAsset(stackswap, tokenStr);
+    if (assetString === 'wstx') {
+        // console.log('tokenamount',tokenAmount.toNumber());
+        return createSTXPostCondition(account, condition, tokenAmount);
+    } else {
+        return createFungiblePostCondition(account, condition, tokenAmount, assetString);
+    }
+}
+
+
+export function num2decimal(input:any, decimal:number){
+    return (new BigNumber(input)).dividedBy(10 ** decimal);
+}
+export function decimal2integer(input:any, decimal:number = 6){
+    return (new BigNumber(input)).multipliedBy(10 ** decimal).toFixed(0);
+}
+
+
+export function numWithComma(input:any, decimal:number) {
+    if(typeof (input) === 'string'){
+        return new BigNumber(input).toNumber().toLocaleString(undefined, { maximumFractionDigits: decimal });
+        // return input.replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ',');
+    }else if(typeof (input) === 'number'){
+        return new BigNumber(input).toNumber().toLocaleString(undefined, { maximumFractionDigits: decimal });
+        // return input.toString().replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ',');
+    }else if(BigNumber.isBigNumber(input)){
+        return input.toNumber().toLocaleString(undefined, { maximumFractionDigits: decimal });
+        // return input.toString().replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ',');
+    }else{
+        return 'ERROR';
+    }
+}
+
+
+
+export function numFormat_ (input:any, decimal:number = 6){
+    const input_bn = new BigNumber(input);
+    if(input_bn.isInteger()){
+        return numWithComma(input_bn, 0);
+    }
+    else{
+        return numWithComma(input_bn.toFixed(decimal, 1), decimal);
+        // if(new BigNumber(10 ** (decimal*-1)) < input_bn) {
+        //
+        // }else{
+        //     return numWithComma(input_bn.toFixed(6, 1));
+        // }
+    }
+}
+
+export function getPriceAndDY(pair: LiquidityPool, amount: string = '-1', x_to_y: boolean = true) : {dy: string, output_price: string} {
+
+    try {
+        const balance_x = x_to_y ? pair.balance_x : pair.balance_y;
+
+        const balance_y = x_to_y ? pair.balance_y : pair.balance_x;
+        const decimal_x = x_to_y ? pair.token_x.decimal : pair.token_y.decimal;
+        const decimal_y = x_to_y ? pair.token_y.decimal : pair.token_x.decimal;
+        let dx2 = new BigNumber(10).exponentiatedBy(decimal_x).multipliedBy(amount).multipliedBy(0.997);
+        if(amount == '-1'){
+            dx2 = new BigNumber(1);
+        }
+        if (dx2.comparedTo(balance_x) >= 0) {
+            // console.log('dx is bigger than dy');
+            return {dy: '0', output_price: '0'};
+        }
+        const dy2 = (new BigNumber(balance_y).multipliedBy(dx2)).dividedBy(new BigNumber(balance_x).plus(dx2));
+        const output_price2 = ((new BigNumber(10).exponentiatedBy(decimal_y)).dividedBy(new BigNumber(10).exponentiatedBy(decimal_x))).toNumber() * ((dx2).toNumber()/(dy2).toNumber());
+        const output_price_final = output_price2.toString()
+        const dy_final = dy2.dividedBy(new BigNumber(10).exponentiatedBy(decimal_y)).toString()
+
+        if(amount == '-1'){
+            return {dy: '0', output_price: output_price_final};
+        }
+        return {dy: dy_final, output_price: output_price_final};
+    } catch (e) {
+        return {dy: '0', output_price: '0'};
+    }
+}
+
+export function getAmountWithDecimalString(amount: number, decimal: number) {
+    BigNumber.config({ EXPONENTIAL_AT: 40 })
+    try{
+        return new BigNumber(10 ** decimal).multipliedBy(amount).toString();
+    } catch (e) {
+        return new BigNumber(10 ** decimal).multipliedBy(new BigNumber(amount)).toString();
+    }
+}
+export function getAmountStringWithDecimal(amount: string, decimal: number) {
+    // console.log(new BigNumber(10 ** decimal).toString());
+    try{
+        return new BigNumber(10 ** decimal).multipliedBy(amount).toString();
+    } catch (e) {
+        return new BigNumber(10 ** decimal).multipliedBy(new BigNumber(amount)).toString();
+    }
+}
+//
+// export function createNonFungiblePostCondition(account: string, condition: NonFungibleConditionCode, assetString: AssetString, assetIdCV: ClarityValue) : NonFungiblePostCondition {
+//     let conditionComparator: NonFungibleComparator = 'sent';
+//     switch (condition) {
+//         case NonFungibleConditionCode.Sends:
+//             conditionComparator = 'sent';
+//             break
+//         case NonFungibleConditionCode.DoesNotSend:
+//             conditionComparator = 'not-sent';
+//             break
+//     }
+//     return {
+//         type: 'nft-postcondition',
+//         address: account,
+//         condition: conditionComparator,
+//         asset: assetString,
+//         assetId: assetIdCV,
+//     };
+// }
+//
+// export function createFungiblePostCondition(account: any, condition: FungibleComparator, assetString: AssetString, amount: string | bigint | number): FungiblePostCondition {
+//     return {
+//         type: 'ft-postcondition',
+//         address: account,
+//         condition: condition,
+//         asset: assetString,
+//         amount: amount,
+//     };
+//
+// }
+//
+// export function createSTXPostCondition(account: any, condition: FungibleComparator, amount: string | bigint | number): StxPostCondition {
+//     return {
+//         type: 'stx-postcondition',
+//         address: account,
+//         condition: condition,
+//         amount: amount,
+//     };
+//
+// }