Constructor for Mint Branded Token

@constructor
484234
function (params) {
  const oThis = this
  ;

  oThis.brandedTokenUuid = params.uuid;
  oThis.amountToStakeInWeis = params.amount_to_stake_in_weis;
  oThis.reserveAddr = params.reserve_address;
  oThis.reservePassphrase = params.reserve_passphrase;
  oThis.erc20Address = params.erc20_address;
}
1271930
function createDiTokenExpression(token) {
    if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__facade_lang__["c" /* isPresent */])(token.value)) {
        return __WEBPACK_IMPORTED_MODULE_2__output_output_ast__["f" /* literal */](token.value);
    }
    else {
        return __WEBPACK_IMPORTED_MODULE_2__output_output_ast__["g" /* importExpr */](token.identifier);
    }
}
385362
function _constructor () {
    converterOptions = converterOptions || {};

    for (var gOpt in globalOptions) {
      if (globalOptions.hasOwnProperty(gOpt)) {
        options[gOpt] = globalOptions[gOpt];
      }
    }

    // Merge options
    if (typeof converterOptions === 'object') {
      for (var opt in converterOptions) {
        if (converterOptions.hasOwnProperty(opt)) {
          options[opt] = converterOptions[opt];
        }
      }
    } else {
      throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions +
      ' was passed instead.');
    }

    if (options.extensions) {
      showdown.helper.forEach(options.extensions, _parseExtension);
    }
  }
1015779
function factory(options) {
  options = _.extend({}, options);

  return tartan.parse([
    tartan.parse.stripe(),
    tartan.parse.literal('('),
    tartan.parse.literal(')'),
    tartan.parse.literal('['),
    tartan.parse.literal(']'),
    tartan.parse.color({
      allowLongNames: true,
      colorPrefix: /[#]/,
      colorSuffix: null,
      colorFormat: 'long',
      allowComment: false
    })
  ], {
    errorHandler: options.errorHandler,
    processTokens: tartan.filter([
      options.processTokens,
      tartan.filter.removeTokens(tartan.defaults.insignificantTokens)
    ]),
    buildSyntaxTree: syntax({
      errorHandler: options.errorHandler,
      processTokens: tartan.filter.classify({
        // Disable some token classes
        isWarpAndWeftSeparator: null,
        isPivot: null,
        isBlockStart: null,
        isBlockEnd: null,

        // Add new token classes
        isWarpStart: function(token) {
          return tartan.utils.token.isLiteral(token) && (token.value == '[');
        },
        isWeftStart: function(token) {
          return tartan.utils.token.isLiteral(token) && (token.value == ']');
        },
        isBlockBodyStart: function(token) {
          return tartan.utils.token.isLiteral(token) && (token.value == '(');
        },
        isBlockBodyEnd: function(token) {
          return tartan.utils.token.isLiteral(token) && (token.value == ')');
        }
      }),
      transformSyntaxTree: options.transformSyntaxTree
    })
  });
}
221113
function createToken(username, done) {
  return getUser(username, function(getUserErr, user) {
    if (getUserErr) {
      return done(getUserErr);
    }

    if (!user) {
      return done(new Error(`user '${username}' not found`));
    }

    const token = uuid.v4();

    return hashToken(token, function(cryptErr, hash) {
      if (cryptErr) {
        return done(cryptErr);
      }

      return getModels(function(m) {
        m.collections.token.create({
          uuid: hash,
          owner: user.id,
        }, function(createTokenErr) {
          if (createTokenErr) {
            return done(createTokenErr);
          }

          return done(null, token);
        }); // m.collections.token.create
      }); // getModels
    }); // hashToken
  }); // getUser
}
375795
function createFactory() {
  return function Stamp(options) {
    var descriptor = Stamp.compose || {};
    // Next line was optimized for most JS VMs. Please, be careful here!
    var obj = {__proto__: descriptor.methods}; // jshint ignore:line

    merge(obj, descriptor.deepProperties);
    assign(obj, descriptor.properties);
    Object.defineProperties(obj, descriptor.propertyDescriptors || {});

    if (!descriptor.initializers || descriptor.initializers.length === 0) return obj;

    if (options === undefined) options = {};
    var inits = descriptor.initializers;
    var length = inits.length;
    for (var i = 0; i < length; i += 1) {
      var initializer = inits[i];
      if (isFunction(initializer)) {
        var returnedValue = initializer.call(obj, options,
          {instance: obj, stamp: Stamp, args: slice.apply(arguments)});
        obj = returnedValue === undefined ? obj : returnedValue;
      }
    }

    return obj;
  };
}
204627
function TokenBucket(timespan, limit, { distFactor = 1, factor = 20, spread = 500 / timespan, now = Date.now } = {}) {
  this.now = now;

  this.timespan = timespan;
  // this.givenLimit is the limit given to the constructor, this.limit is the
  // functional limit, accounting for this.distFactor.
  this.givenLimit = limit;
  this.factor = factor;
  this.spread = spread;
  this.timespanIndex = Math.ceil(timespan / factor);
  this.total = 0;
  this.time = -1;
  this.buffer = new Array(this.factor + 1).fill(0);

  this.setDistFactor(distFactor);
}
645116
function(tokenObject) {
                var that = this;

                if (this.driver._refreshHandlerPromise) {
                    return this.driver._refreshHandlerPromise;
                }

                if (tokenObject.refreshToken) {
                    console.log('corbeljs:services:token:refresh');
                    this.driver._refreshHandlerPromise = this.driver.iam.token().refresh(
                        tokenObject.refreshToken,
                        this.driver.config.get(corbel.Iam.IAM_TOKEN_SCOPES, '')
                    );

                } else {
                    console.log('corbeljs:services:token:create');
                    this.driver._refreshHandlerPromise = this.driver.iam.token().create();
                }

                return this.driver._refreshHandlerPromise
                    .then(function(response) {
                        that.driver.trigger('token:refresh', response.data);
                        that.driver._refreshHandlerPromise = null;
                        return response;
                    }).catch(function(err) {
                        that.driver._refreshHandlerPromise = null;
                        throw err;
                    });
            }
752494
async function () {
    const oThis = this
    ;

    // validations
    if (!basicHelper.isUuidValid(oThis.uuid)) {
      let errObj = responseHelper.error({
        internal_error_identifier: 's_u_gbtd_1',
        api_error_identifier: 'invalid_branded_token_uuid',
        error_config: basicHelper.fetchErrorConfig()
      });
      return Promise.resolve(errObj);
    }

    var tokenDetails = await openSTValue.utilityTokens(oThis.uuid);

    return tokenDetails;
  }
1096053
def mint_token_if_balance_low(
        token_contract: ContractProxy,
        target_address: str,
        min_balance: int,
        fund_amount: int,
        gas_limit: int,
        mint_msg: str,
        no_action_msg: str = None,
) -> Optional[TransactionHash]:
    
    balance = token_contract.contract.functions.balanceOf(target_address).call()
    if balance < min_balance:
        mint_amount = fund_amount - balance
        log.debug(mint_msg, address=target_address, amount=mint_amount)
        return token_contract.transact('mintFor', gas_limit, mint_amount, target_address)
    else:
        if no_action_msg:
            log.debug(no_action_msg, balance=balance)

    return None
725321
function NodeWithToken(str, start, end) {
        this.name = str;
        this.start = start;
        this.end = end;
}
834289
async function () {
    logger.step("** Starting stake mint for st prime for beneficiary utilityChainOwner");
    const oThis = this
      , toStakeAmount = (new BigNumber(10000)).mul(new BigNumber(10).toPower(18))
    ;

    logger.info('* Utility Chain Owner transfers ST to staker');
    await fundManager.transferST(
        utilityChainOwnerAddr, utilityChainOwnerPassphrase, stakerAddr, toStakeAmount,
        {tag: 'transferSTToStaker', returnType: 'txReceipt'}
    );

    logger.info('* Staker approves openSTValue contract');
    const approveResponse = await (new approveService()).perform();
    if (approveResponse.isFailure()) {
      process.exit(1);
    }

    const approveTransactionHash = approveResponse.data.transaction_hash;

    logger.info('* Get approval status and keep doing so till success');
    const approveReceiptResponse =  await contractInteractHelper.waitAndGetTransactionReceipt(web3Provider, approveTransactionHash, {});
    if (!approveReceiptResponse.isSuccess()) {
      logger.error('Approval receipt error ', approveReceiptResponse);
      process.exit(1);
    }

    logger.info('* Start stake');

    await (new startStakeService({
      beneficiary: utilityChainOwnerAddr,
      to_stake_amount: toStakeAmount,
      uuid: coreConstants.OST_OPENSTUTILITY_ST_PRIME_UUID
    })).perform();

    await oThis._waitForSTPrimeMint();

    return Promise.resolve(responseHelper.successWithData({}));
  }
749633
function newToken(){ // check if the client has all the tokens
	var allRetrieved = true;
	var tokens = client.getTokens();
	
	['auth', 'gvx', 'rnr'].forEach(function(type){
		if(!tokens.hasOwnProperty(type)){
			allRetrieved = false;
		}
	});
	
	if(allRetrieved){ // save tokens once all have been retrieved
		fs.writeFileSync('./tokens.json', JSON.stringify(tokens));
		console.log('\n\nALL TOKENS SAVED TO tokens.json')
	}
}
1337193
private function constructIdentityToken() {
		if (isset($_REQUEST[self::CODE])) {
			$this->requestToken($_REQUEST[self::CODE], self::IDENTITY_TOKEN);
			$_SESSION[self::SESSION][self::IS_API_TOKEN] = false;
			$_SESSION[self::SESSION][self::STATE] = self::NEGOTIATION_COMPLETE;
			header("Location: {$_SESSION[self::SESSION][self::LANDING_PAGE]}");
			exit;
		} elseif (isset($_REQUEST[self::ERROR])) {
			$_SESSION[self::SESSION][self::STATE] = self::NEGOTIATION_FAILED;
			$_SESSION[self::SESSION][self::ERROR] = $_REQUEST[self::ERROR];
			header("Location: {$_SESSION[self::SESSION][self::LANDING_PAGE]}?error={$_REQUEST[self::ERROR]}");
			exit;
		} else {
			throw new OAuthNegotiator_Exception(
				'Unexpected OAuth response',
				OAuthNegotiator_Exception::CODE_RESPONSE
			);
		}
	}
1361656
function assign (key, token) {
  validator('tokenLabel', key)
  validator('token', token)

  tokens[key] = token
}
1332742
async function() {
    const oThis = this
    ;

    await new openSTStorage.TokenBalanceModel({
      ddb_service: ddbServiceObj,
      auto_scaling: autoScalingServiceObj,
      erc20_contract_address: oThis.erc20
    }).allocate();
  }
1181576
function() {
    var captures;
    if (captures = /^(-)?(\d+\.\d+|\d+|\.\d+)(%|[a-zA-Z]+)?[ \t]*/.exec(this.str)) {
      this.skip(captures);
      var n = parseFloat(captures[2]);
      if ('-' == captures[1]) n = -n;
      var node = new nodes.Unit(n, captures[3]);
      node.raw = captures[0];
      return new Token('unit', node);
    }
  }