White Error XDCpay #14

xcantera · 2022-09-13T13:45:55Z

I got this error few times. You need to delete XDCpay and install again and put your seed key.

`..

256320
256321
256322
256323
256324
256325
256326
256327
256328
256329
256330
256331
256332
256333
256334
256335
256336
256337
256338
256339
256340
256341
256342
256343
256344
256345
256346
256347
256348
256349
256350
256351
256352
256353
256354
256355
256356
256357
256358
256359
256360
256361
256362
256363
256364
256365
256366
256367
256368
256369
256370
256371
256372
256373
256374
256375
256376
256377
256378
256379
256380
256381
256382
256383
256384
256385
256386
256387
256388
256389
256390
256391
256392
256393
256394
256395
256396
256397
256398
256399
256400
256401
256402
256403
256404
256405
256406
256407
256408
256409
256410
256411
256412
256413
256414
256415
256416
256417
256418
256419
256420
256421
256422
256423
256424
256425
256426
256427
256428
256429
256430
256431
256432
256433
256434
256435
256436
256437
256438
256439
256440
256441
256442
256443
256444
256445
256446
256447
256448
256449
256450
256451
256452
256453
256454
256455
256456
256457
256458
256459
256460
256461
256462
256463
256464
256465
256466
256467
256468
256469
256470
256471
256472
256473
256474
256475
256476
256477
256478
256479
256480
256481
256482
256483
256484
256485
256486
256487
256488
256489
256490
256491
256492
256493
256494
256495
256496
256497
256498
256499
256500
256501
256502
256503
256504
256505
256506
256507
256508
256509
256510
256511
256512
256513
256514
256515
256516
256517
256518
256519
256520
256521
256522
256523
256524
256525
256526
256527
256528
256529
256530
256531
256532
256533
256534
256535
256536
256537
256538
256539
256540
256541
256542
256543
256544
256545
256546
256547
256548
256549
256550
256551
256552
256553
256554
256555
256556
256557
256558
256559
256560
256561
256562
256563
256564
256565
256566
256567
256568
256569
256570
256571
256572
256573
256574
256575
256576
256577
256578
256579
256580
256581
256582
256583
256584
256585
256586
256587
256588
256589
256590
256591
256592
256593
256594
256595
256596
256597
256598
256599
256600
256601
256602
256603
256604
256605
256606
256607
256608
256609
256610
256611
256612
256613
256614
256615
256616
256617
256618
256619
256620
256621
256622
256623
256624
256625
256626
256627
256628
256629
256630
256631
256632
256633
256634
256635
256636
256637
256638
256639
256640
256641
256642
256643
256644
256645
256646
256647
256648
256649
256650
256651
256652
256653
256654
256655
256656
256657
256658
256659
256660
256661
256662
256663
256664
256665
256666
256667
256668
256669
256670
256671
256672
256673
256674
256675
256676
256677
256678
256679
256680
256681
256682
256683
256684
256685
256686
256687
256688
256689
256690
256691
256692
256693
256694
256695
256696
256697
256698
256699
256700
256701
256702
256703
256704
256705
256706
256707
256708
256709
256710
256711
256712
256713
256714
256715
256716
256717
256718
256719
256720
256721
256722
256723
256724
256725
256726
256727
256728
256729
256730
256731
256732
256733
256734
256735
256736
256737
256738
256739
256740
256741
256742
256743
256744
256745
256746
256747
256748
256749
256750
256751
256752
256753
256754
256755
256756
256757
256758
256759
256760
256761
256762
256763
256764
256765
256766
256767
256768
256769
256770
256771
256772
256773
256774
256775
256776
256777
256778
256779
256780
256781
256782
256783
256784
256785
256786
256787
256788
256789
256790
256791
256792
256793
256794
256795
256796
256797
256798
256799
256800
256801
256802
256803
256804
256805
256806
256807
256808
256809
256810
256811
256812
256813
256814
256815
256816
256817
256818
256819
256820
256821
256822
256823
256824
256825
256826
256827
256828
256829
256830
256831
256832
256833
256834
256835
256836
256837
256838
256839
256840
256841
256842
256843
256844
256845
256846
256847
256848
256849
256850
256851
256852
256853
256854
256855
256856
256857
256858
256859
256860
256861
256862
256863
256864
256865
256866
256867
256868
256869
256870
256871
256872
256873
256874
256875
256876
256877
256878
256879
256880
256881
256882
256883
256884
256885
256886
256887
256888
256889
256890
256891
256892
256893
256894
256895
256896
256897
256898
256899
256900
256901
256902
256903
256904
256905
256906
256907
256908
256909
256910
256911
256912
256913
256914
256915
256916
256917
256918
256919
256920
256921
256922
256923
256924
256925
256926
256927
256928
256929
256930
256931
256932
256933
256934
256935
256936
256937
256938
256939
256940
256941
256942
256943
256944
256945
256946
256947
256948
256949
256950
256951
256952
256953
256954
256955
256956
256957
256958
256959
256960
256961
256962
256963
256964
256965
256966
256967
256968
256969
256970
256971
256972
256973
256974
256975
256976
256977
256978
256979
256980
256981
256982
256983
256984
256985
256986
256987
256988
256989
256990
256991
256992
256993
256994
256995
256996
256997
256998
256999
257000
257001
257002
257003
257004
257005
257006
257007
257008
257009
257010
257011
257012
257013
257014
257015
257016
257017
257018
257019
257020
257021
257022
257023
257024
257025
257026
257027
257028
257029
257030
257031
257032
257033
257034
257035
257036
257037
257038
257039
257040
257041
257042
257043
257044
257045
257046
257047
257048
257049
257050
257051
257052
257053
257054
257055
257056
257057
257058
257059
257060
257061
257062
257063
257064
257065
257066
257067
257068
257069
257070
257071
257072
257073
257074
257075
257076
257077
257078
257079
257080
257081
257082
257083
257084
257085
257086
257087
257088
257089
257090
257091
257092
257093
257094
257095
257096
257097
257098
257099
257100
257101
257102
257103
257104
257105
257106
257107
257108
257109
257110
257111
257112
257113
257114
257115
257116
257117
257118
257119
257120
257121
257122
257123
257124
257125
257126
257127
257128
257129
257130
257131
257132
257133
257134
257135
257136
257137
257138
257139
257140
257141
257142
257143
257144
257145
257146
257147
257148
257149
257150
257151
257152
257153
257154
257155
257156
257157
257158
257159
257160
257161
257162
257163
257164
257165
257166
257167
257168
257169
257170
257171
257172
257173
257174
257175
257176
257177
257178
257179
257180
257181
257182
257183
257184
257185
257186
257187
257188
257189
257190
257191
257192
257193
257194
257195
257196
257197
257198
257199
257200
257201
257202
257203
257204
257205
257206
257207
257208
257209
257210
257211
257212
257213
257214
257215
257216
257217
257218
257219
257220
257221
257222
257223
257224
257225
257226
257227
257228
257229
257230
257231
257232
257233
257234
257235
257236
257237
257238
257239
257240
257241
257242
257243
257244
257245
257246
257247
257248
257249
257250
257251
257252
257253
257254
257255
257256
257257
257258
257259
257260
257261
257262
257263
257264
257265
257266
257267
257268
257269
257270
257271
257272
257273
257274
257275
257276
257277
257278
257279
257280
257281
257282
257283
257284
257285
257286
257287
257288
257289
257290
257291
257292
257293
257294
257295
257296
257297
257298
257299
257300
257301
257302
257303
257304
257305
257306
257307
257308
257309
257310
257311
257312
257313
257314
257315
257316
257317
257318
...
[[getLinesNotShownLabel_( truncatedBefore_, '', '')]]
throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
}

if (typeof offset === 'function') {
cb = offset
offset = 0
size = buf.length
} else if (typeof size === 'function') {
cb = size
size = buf.length - offset
} else if (typeof cb !== 'function') {
throw new TypeError('"cb" argument must be a function')
}
assertOffset(offset, buf.length)
assertSize(size, offset, buf.length)
return actualFill(buf, offset, size, cb)
}

function actualFill (buf, offset, size, cb) {
if (process.browser) {
var ourBuf = buf.buffer
var uint = new Uint8Array(ourBuf, offset, size)
crypto.getRandomValues(uint)
if (cb) {
process.nextTick(function () {
cb(null, buf)
})
return
}
return buf
}
if (cb) {
randombytes(size, function (err, bytes) {
if (err) {
return cb(err)
}
bytes.copy(buf, offset)
cb(null, buf)
})
return
}
var bytes = randombytes(size)
bytes.copy(buf, offset)
return buf
}
function randomFillSync (buf, offset, size) {
if (typeof offset === 'undefined') {
offset = 0
}
if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
throw new TypeError('"buf" argument must be a Buffer or Uint8Array')
}

assertOffset(offset, buf.length)

if (size === undefined) size = buf.length - offset

assertSize(size, offset, buf.length)

return actualFill(buf, offset, size)
}

}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"_process":756,"randombytes":1842,"safe-buffer":2239}],1844:[function(require,module,exports){
function RavenConfigError(message) {
this.name = 'RavenConfigError';
this.message = message;
}
RavenConfigError.prototype = new Error();
RavenConfigError.prototype.constructor = RavenConfigError;

module.exports = RavenConfigError;

},{}],1845:[function(require,module,exports){
var utils = require('./utils');

var wrapMethod = function(console, level, callback) {
var originalConsoleLevel = console[level];
var originalConsole = console;

if (!(level in console)) {
return;
}

var sentryLevel = level === 'warn' ? 'warning' : level;

console[level] = function() {
var args = [].slice.call(arguments);

var msg = utils.safeJoin(args, ' ');
var data = {level: sentryLevel, logger: 'console', extra: {arguments: args}};

if (level === 'assert') {
  if (args[0] === false) {
    // Default browsers message
    msg =
      'Assertion failed: ' + (utils.safeJoin(args.slice(1), ' ') || 'console.assert');
    data.extra.arguments = args.slice(1);
    callback && callback(msg, data);
  }
} else {
  callback && callback(msg, data);
}

// this fails for some browsers. :(
if (originalConsoleLevel) {
  // IE9 doesn't allow calling apply on console functions directly
  // See: https://stackoverflow.com/questions/5472938/does-ie9-support-console-log-and-is-it-a-real-function#answer-5473193
  Function.prototype.apply.call(originalConsoleLevel, originalConsole, args);
}

};
};

module.exports = {
wrapMethod: wrapMethod
};

},{"./utils":1848}],1846:[function(require,module,exports){
(function (global){(function (){
/*global XDomainRequest:false */

var TraceKit = require('../vendor/TraceKit/tracekit');
var stringify = require('../vendor/json-stringify-safe/stringify');
var md5 = require('../vendor/md5/md5');
var RavenConfigError = require('./configError');

var utils = require('./utils');
var isErrorEvent = utils.isErrorEvent;
var isDOMError = utils.isDOMError;
var isDOMException = utils.isDOMException;
var isError = utils.isError;
var isObject = utils.isObject;
var isPlainObject = utils.isPlainObject;
var isUndefined = utils.isUndefined;
var isFunction = utils.isFunction;
var isString = utils.isString;
var isArray = utils.isArray;
var isEmptyObject = utils.isEmptyObject;
var each = utils.each;
var objectMerge = utils.objectMerge;
var truncate = utils.truncate;
var objectFrozen = utils.objectFrozen;
var hasKey = utils.hasKey;
var joinRegExp = utils.joinRegExp;
var urlencode = utils.urlencode;
var uuid4 = utils.uuid4;
var htmlTreeAsString = utils.htmlTreeAsString;
var isSameException = utils.isSameException;
var isSameStacktrace = utils.isSameStacktrace;
var parseUrl = utils.parseUrl;
var fill = utils.fill;
var supportsFetch = utils.supportsFetch;
var supportsReferrerPolicy = utils.supportsReferrerPolicy;
var serializeKeysForMessage = utils.serializeKeysForMessage;
var serializeException = utils.serializeException;
var sanitize = utils.sanitize;

var wrapConsoleMethod = require('./console').wrapMethod;

var dsnKeys = 'source protocol user pass host port path'.split(' '),
dsnPattern = /^(?:(\w+):)?//(?:(\w+)(:\w+)?@)?([\w.-]+)(?::(\d+))?(/.*)/;

function now() {
return +new Date();
}

// This is to be defensive in environments where window does not exist (see getsentry/sentry-javascript#785)
var _window =
typeof window !== 'undefined'
? window
: typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var _document = _window.document;
var _navigator = _window.navigator;

function keepOriginalCallback(original, callback) {
return isFunction(callback)
? function(data) {
return callback(data, original);
}
: callback;
}

// First, check for JSON support
// If there is no JSON, we no-op the core features of Raven
// since JSON is required to encode the payload
function Raven() {
this._hasJSON = !!(typeof JSON === 'object' && JSON.stringify);
// Raven can run in contexts where there's no document (react-native)
this._hasDocument = !isUndefined(_document);
this._hasNavigator = !isUndefined(_navigator);
this._lastCapturedException = null;
this._lastData = null;
this._lastEventId = null;
this._globalServer = null;
this._globalKey = null;
this._globalProject = null;
this._globalContext = {};
this._globalOptions = {
// SENTRY_RELEASE can be injected by https://github.com/getsentry/sentry-webpack-plugin
release: _window.SENTRY_RELEASE && _window.SENTRY_RELEASE.id,
logger: 'javascript',
ignoreErrors: [],
ignoreUrls: [],
whitelistUrls: [],
includePaths: [],
headers: null,
collectWindowErrors: true,
captureUnhandledRejections: true,
maxMessageLength: 0,
// By default, truncates URL values to 250 chars
maxUrlLength: 250,
stackTraceLimit: 50,
autoBreadcrumbs: true,
instrument: true,
sampleRate: 1,
sanitizeKeys: []
};
this._fetchDefaults = {
method: 'POST',
// Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
// https://caniuse.com/#feat=referrer-policy
// It doesn't. And it throw exception instead of ignoring this parameter...
// REF: getsentry/sentry-javascript#1233
referrerPolicy: supportsReferrerPolicy() ? 'origin' : ''
};
this._ignoreOnError = 0;
this._isRavenInstalled = false;
this._originalErrorStackTraceLimit = Error.stackTraceLimit;
// capture references to window.console and all its methods first
// before the console plugin has a chance to monkey patch
this._originalConsole = _window.console || {};
this._originalConsoleMethods = {};
this._plugins = [];
this._startTime = now();
this._wrappedBuiltIns = [];
this._breadcrumbs = [];
this._lastCapturedEvent = null;
this._keypressTimeout;
this._location = _window.location;
this._lastHref = this._location && this._location.href;
this._resetBackoff();

// eslint-disable-next-line guard-for-in
for (var method in this._originalConsole) {
this._originalConsoleMethods[method] = this._originalConsole[method];
}
}

/*

The core Raven singleton
@this {Raven}
*/

Raven.prototype = {
// Hardcode version string so that raven source can be loaded directly via
// webpack (using a build step causes webpack #1617). Grunt verifies that
// this value matches package.json during build.
// See: getsentry/sentry-javascript#465
VERSION: '3.27.2',

debug: false,

TraceKit: TraceKit, // alias to TraceKit

/*
* Configure Raven with a DSN and extra options
*
* @param {string} dsn The public Sentry DSN
* @param {object} options Set of global options [optional]
* @return {Raven}
*/
config: function(dsn, options) {
var self = this;

if (self._globalServer) {
  this._logDebug('error', 'Error: Raven has already been configured');
  return self;
}
if (!dsn) return self;

var globalOptions = self._globalOptions;

// merge in options
if (options) {
  each(options, function(key, value) {
    // tags and extra are special and need to be put into context
    if (key === 'tags' || key === 'extra' || key === 'user') {
      self._globalContext[key] = value;
    } else {
      globalOptions[key] = value;
    }
  });
}

self.setDSN(dsn);

// "Script error." is hard coded into browsers for errors that it can't read.
// this is the result of a script being pulled in from an external domain and CORS.
globalOptions.ignoreErrors.push(/^Script error\.?$/);
globalOptions.ignoreErrors.push(/^Javascript error: Script error\.? on line 0$/);

// join regexp rules into one big rule
globalOptions.ignoreErrors = joinRegExp(globalOptions.ignoreErrors);
globalOptions.ignoreUrls = globalOptions.ignoreUrls.length
  ? joinRegExp(globalOptions.ignoreUrls)
  : false;
globalOptions.whitelistUrls = globalOptions.whitelistUrls.length
  ? joinRegExp(globalOptions.whitelistUrls)
  : false;
globalOptions.includePaths = joinRegExp(globalOptions.includePaths);
globalOptions.maxBreadcrumbs = Math.max(
  0,
  Math.min(globalOptions.maxBreadcrumbs || 100, 100)
); // default and hard limit is 100

var autoBreadcrumbDefaults = {
  xhr: true,
  console: true,
  dom: true,
  location: true,
  sentry: true
};

var autoBreadcrumbs = globalOptions.autoBreadcrumbs;
if ({}.toString.call(autoBreadcrumbs) === '[object Object]') {
  autoBreadcrumbs = objectMerge(autoBreadcrumbDefaults, autoBreadcrumbs);
} else if (autoBreadcrumbs !== false) {
  autoBreadcrumbs = autoBreadcrumbDefaults;
}
globalOptions.autoBreadcrumbs = autoBreadcrumbs;

var instrumentDefaults = {
  tryCatch: true
};

var instrument = globalOptions.instrument;
if ({}.toString.call(instrument) === '[object Object]') {
  instrument = objectMerge(instrumentDefaults, instrument);
} else if (instrument !== false) {
  instrument = instrumentDefaults;
}
globalOptions.instrument = instrument;

TraceKit.collectWindowErrors = !!globalOptions.collectWindowErrors;

// return for chaining
return self;

},

/*
* Installs a global window.onerror error handler
* to capture and report uncaught exceptions.
* At this point, install() is required to be called due
* to the way TraceKit is set up.
*
* @return {Raven}
*/
install: function() {
var self = this;
if (self.isSetup() && !self._isRavenInstalled) {
TraceKit.report.subscribe(function() {
self._handleOnErrorStackInfo.apply(self, arguments);
});

  if (self._globalOptions.captureUnhandledRejections) {
    self._attachPromiseRejectionHandler();
  }

  self._patchFunctionToString();

  if (self._globalOptions.instrument && self._globalOptions.instrument.tryCatch) {
    self._instrumentTryCatch();
  }

  if (self._globalOptions.autoBreadcrumbs) self._instrumentBreadcrumbs();

  // Install all of the plugins
  self._drainPlugins();

  self._isRavenInstalled = true;
}

Error.stackTraceLimit = self._globalOptions.stackTraceLimit;
return this;

},

/*
* Set the DSN (can be called multiple time unlike config)
*
* @param {string} dsn The public Sentry DSN
*/
setDSN: function(dsn) {
var self = this,
uri = self._parseDSN(dsn),
lastSlash = uri.path.lastIndexOf('/'),
path = uri.path.substr(1, lastSlash);

self._dsn = dsn;
self._globalKey = uri.user;
self._globalSecret = uri.pass && uri.pass.substr(1);
self._globalProject = uri.path.substr(lastSlash + 1);

self._globalServer = self._getGlobalServer(uri);

self._globalEndpoint =
  self._globalServer + '/' + path + 'api/' + self._globalProject + '/store/';

// Reset backoff state since we may be pointing at a
// new project/server
this._resetBackoff();

},

/*
* Wrap code within a context so Raven can capture errors
* reliably across domains that is executed immediately.
*
* @param {object} options A specific set of options for this context [optional]
* @param {function} func The callback to be immediately executed within the context
* @param {array} args An array of arguments to be called with the callback [optional]
*/
context: function(options, func, args) {
if (isFunction(options)) {
args = func || [];
func = options;
options = {};
}

return this.wrap(options, func).apply(this, args);

},

/*
* Wrap code within a context and returns back a new function to be executed
*
* @param {object} options A specific set of options for this context [optional]
* @param {function} func The function to be wrapped in a new context
* @param {function} _before A function to call before the try/catch wrapper [optional, private]
* @return {function} The newly wrapped functions with a context
*/
wrap: function(options, func, _before) {
var self = this;
// 1 argument has been passed, and it's not a function
// so just return it
if (isUndefined(func) && !isFunction(options)) {
return options;
}

// options is optional
if (isFunction(options)) {
  func = options;
  options = undefined;
}

// At this point, we've passed along 2 arguments, and the second one
// is not a function either, so we'll just return the second argument.
if (!isFunction(func)) {
  return func;
}

// We don't wanna wrap it twice!
try {
  if (func.__raven__) {
    return func;
  }

  // If this has already been wrapped in the past, return that
  if (func.__raven_wrapper__) {
    return func.__raven_wrapper__;
  }
} catch (e) {
  // Just accessing custom props in some Selenium environments
  // can cause a "Permission denied" exception (see raven-js#495).
  // Bail on wrapping and return the function as-is (defers to window.onerror).
  return func;
}

function wrapped() {
  var args = [],
    i = arguments.length,
    deep = !options || (options && options.deep !== false);

  if (_before && isFunction(_before)) {
    _before.apply(this, arguments);
  }

  // Recursively wrap all of a function's arguments that are
  // functions themselves.
  while (i--) args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];

  try {
    // Attempt to invoke user-land function
    // NOTE: If you are a Sentry user, and you are seeing this stack frame, it
    //       means Raven caught an error invoking your application code. This is
    //       expected behavior and NOT indicative of a bug with Raven.js.
    return func.apply(this, args);
  } catch (e) {
    self._ignoreNextOnError();
    self.captureException(e, options);
    throw e;
  }
}

// copy over properties of the old function
for (var property in func) {
  if (hasKey(func, property)) {
    wrapped[property] = func[property];
  }
}
wrapped.prototype = func.prototype;

func.__raven_wrapper__ = wrapped;
// Signal that this function has been wrapped/filled already
// for both debugging and to prevent it to being wrapped/filled twice
wrapped.__raven__ = true;
wrapped.__orig__ = func;

return wrapped;

},

/**

Uninstalls the global error handler.
@return {Raven}
*/
uninstall: function() {
TraceKit.report.uninstall();

this._detachPromiseRejectionHandler();
this._unpatchFunctionToString();
this._restoreBuiltIns();
this._restoreConsole();

Error.stackTraceLimit = this._originalErrorStackTraceLimit;
this._isRavenInstalled = false;

return this;

},

/**

Callback used for unhandledrejection event
@param {PromiseRejectionEvent} event An object containing
promise: the Promise that was rejected
reason: the value with which the Promise was rejected
@return void
*/
_promiseRejectionHandler: function(event) {
this._logDebug('debug', 'Raven caught unhandled promise rejection:', event);
this.captureException(event.reason, {
mechanism: {
type: 'onunhandledrejection',
handled: false
}
});
},

/**

Installs the global promise rejection handler.
@return {raven}
*/
_attachPromiseRejectionHandler: function() {
this._promiseRejectionHandler = this._promiseRejectionHandler.bind(this);
_window.addEventListener &&
_window.addEventListener('unhandledrejection', this._promiseRejectionHandler);
return this;
},

/**

Uninstalls the global promise rejection handler.
@return {raven}
*/
_detachPromiseRejectionHandler: function() {
_window.removeEventListener &&
_window.removeEventListener('unhandledrejection', this._promiseRejectionHandler);
return this;
},

/**

Manually capture an exception and send it over to Sentry
@param {error} ex An exception to be logged
@param {object} options A specific set of options for this error [optional]
@return {Raven}
*/
captureException: function(ex, options) {
options = objectMerge({trimHeadFrames: 0}, options ? options : {});

if (isErrorEvent(ex) && ex.error) {
  // If it is an ErrorEvent with `error` property, extract it to get actual Error
  ex = ex.error;
} else if (isDOMError(ex) || isDOMException(ex)) {
  // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)
  // then we just extract the name and message, as they don't provide anything else
  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
  var name = ex.name || (isDOMError(ex) ? 'DOMError' : 'DOMException');
  var message = ex.message ? name + ': ' + ex.message : name;

  return this.captureMessage(
    message,
    objectMerge(options, {
      // neither DOMError or DOMException provide stack trace and we most likely wont get it this way as well
      // but it's barely any overhead so we may at least try
      stacktrace: true,
      trimHeadFrames: options.trimHeadFrames + 1
    })
  );
} else if (isError(ex)) {
  // we have a real Error object
  ex = ex;
} else if (isPlainObject(ex)) {
  // If it is plain Object, serialize it manually and extract options
  // This will allow us to group events based on top-level keys
  // which is much better than creating new group when any key/value change
  options = this._getCaptureExceptionOptionsFromPlainObject(options, ex);
  ex = new Error(options.message);
} else {
  // If none of previous checks were valid, then it means that
  // it's not a DOMError/DOMException
  // it's not a plain Object
  // it's not a valid ErrorEvent (one with an error property)
  // it's not an Error
  // So bail out and capture it as a simple message:
  return this.captureMessage(
    ex,
    objectMerge(options, {
      stacktrace: true, // if we fall back to captureMessage, default to attempting a new trace
      trimHeadFrames: options.trimHeadFrames + 1
    })
  );
}

// Store the raw exception object for potential debugging and introspection
this._lastCapturedException = ex;

// TraceKit.report will re-raise any exception passed to it,
// which means you have to wrap it in try/catch. Instead, we
// can wrap it here and only re-raise if TraceKit.report
// raises an exception different from the one we asked to
// report on.
try {
  var stack = TraceKit.computeStackTrace(ex);
  this._handleStackInfo(stack, options);
} catch (ex1) {
  if (ex !== ex1) {
    throw ex1;
  }
}

return this;

},

_getCaptureExceptionOptionsFromPlainObject: function(currentOptions, ex) {
var exKeys = Object.keys(ex).sort();
var options = objectMerge(currentOptions, {
message:
'Non-Error exception captured with keys: ' + serializeKeysForMessage(exKeys),
fingerprint: [md5(exKeys)],
extra: currentOptions.extra || {}
});
options.extra.serialized = serializeException(ex);

return options;

},

/*
* Manually send a message to Sentry
*
* @param {string} msg A plain message to be captured in Sentry
* @param {object} options A specific set of options for this message [optional]
* @return {Raven}
*/
captureMessage: function(msg, options) {
// config() automagically converts ignoreErrors from a list to a RegExp so we need to test for an
// early call; we'll error on the side of logging anything called before configuration since it's
// probably something you should see:
if (
!!this._globalOptions.ignoreErrors.test &&
this._globalOptions.ignoreErrors.test(msg)
) {
return;
}

options = options || {};
msg = msg + ''; // Make sure it's actually a string

var data = objectMerge(
  {
    message: msg
  },
  options
);

var ex;
// Generate a "synthetic" stack trace from this point.
// NOTE: If you are a Sentry user, and you are seeing this stack frame, it is NOT indicative
//       of a bug with Raven.js. Sentry generates synthetic traces either by configuration,
//       or if it catches a thrown object without a "stack" property.
try {
  throw new Error(msg);
} catch (ex1) {
  ex = ex1;
}

// null exception name so `Error` isn't prefixed to msg
ex.name = null;
var stack = TraceKit.computeStackTrace(ex);

// stack[0] is `throw new Error(msg)` call itself, we are interested in the frame that was just before that, stack[1]
var initialCall = isArray(stack.stack) && stack.stack[1];

// if stack[1] is `Raven.captureException`, it means that someone passed a string to it and we redirected that call
// to be handled by `captureMessage`, thus `initialCall` is the 3rd one, not 2nd
// initialCall => captureException(string) => captureMessage(string)
if (initialCall && initialCall.func === 'Raven.captureException') {
  initialCall = stack.stack[2];
}

var fileurl = (initialCall && initialCall.url) || '';

if (
  !!this._globalOptions.ignoreUrls.test &&
  this._globalOptions.ignoreUrls.test(fileurl)
) {
  return;
}

if (
  !!this._globalOptions.whitelistUrls.test &&
  !this._globalOptions.whitelistUrls.test(fileurl)
) {
  return;
}

// Always attempt to get stacktrace if message is empty.
// It's the only way to provide any helpful information to the user.
if (this._globalOptions.stacktrace || options.stacktrace || data.message === '') {
  // fingerprint on msg, not stack trace (legacy behavior, could be revisited)
  data.fingerprint = data.fingerprint == null ? msg : data.fingerprint;

  options = objectMerge(
    {
      trimHeadFrames: 0
    },
    options
  );
  // Since we know this is a synthetic trace, the top frame (this function call)
  // MUST be from Raven.js, so mark it for trimming
  // We add to the trim counter so that callers can choose to trim extra frames, such
  // as utility functions.
  options.trimHeadFrames += 1;

  var frames = this._prepareFrames(stack, options);
  data.stacktrace = {
    // Sentry expects frames oldest to newest
    frames: frames.reverse()
  };
}

// Make sure that fingerprint is always wrapped in an array
if (data.fingerprint) {
  data.fingerprint = isArray(data.fingerprint)
    ? data.fingerprint
    : [data.fingerprint];
}

// Fire away!
this._send(data);

return this;

},

captureBreadcrumb: function(obj) {
var crumb = objectMerge(
{
timestamp: now() / 1000
},
obj
);

if (isFunction(this._globalOptions.breadcrumbCallback)) {
  var result = this._globalOptions.breadcrumbCallback(crumb);

  if (isObject(result) && !isEmptyObject(result)) {
    crumb = result;
  } else if (result === false) {
    return this;
  }
}

this._breadcrumbs.push(crumb);
if (this._breadcrumbs.length > this._globalOptions.maxBreadcrumbs) {
  this._breadcrumbs.shift();
}
return this;

},

addPlugin: function(plugin /arg1, arg2, ... argN/) {
var pluginArgs = [].slice.call(arguments, 1);

this._plugins.push([plugin, pluginArgs]);
if (this._isRavenInstalled) {
  this._drainPlugins();
}

return this;

},

/*
* Set/clear a user to be sent along with the payload.
*
* @param {object} user An object representing user data [optional]
* @return {Raven}
*/
setUserContext: function(user) {
// Intentionally do not merge here since that's an unexpected behavior.
this._globalContext.user = user;

return this;

},

/*
* Merge extra attributes to be sent along with the payload.
*
* @param {object} extra An object representing extra data [optional]
* @return {Raven}
*/
setExtraContext: function(extra) {
this._mergeContext('extra', extra);

return this;

},

/*
* Merge tags to be sent along with the payload.
*
* @param {object} tags An object representing tags [optional]
* @return {Raven}
*/
setTagsContext: function(tags) {
this._mergeContext('tags', tags);

return this;

},

/*
* Clear all of the context.
*
* @return {Raven}
*/
clearContext: function() {
this._globalContext = {};

return this;

},

/*
* Get a copy of the current context. This cannot be mutated.
*
* @return {object} copy of context
*/
getContext: function() {
// lol javascript
return JSON.parse(stringify(this._globalContext));
},

/*
* Set environment of application
*
* @param {string} environment Typically something like 'production'.
* @return {Raven}
*/
setEnvironment: function(environment) {
this._globalOptions.environment = environment;

return this;

},

/*
* Set release version of application
*
* @param {string} release Typically something like a git SHA to identify version
* @return {Raven}
*/
setRelease: function(release) {
this._globalOptions.release = release;

return this;

},

/*
* Set the dataCallback option
*
* @param {function} callback The callback to run which allows the
* data blob to be mutated before sending
* @return {Raven}
*/
setDataCallback: function(callback) {
var original = this._globalOptions.dataCallback;
this._globalOptions.dataCallback = keepOriginalCallback(original, callback);
return this;
},

/*
* Set the breadcrumbCallback option
*
* @param {function} callback The callback to run which allows filtering
* or mutating breadcrumbs
* @return {Raven}
*/
setBreadcrumbCallback: function(callback) {
var original = this._globalOptions.breadcrumbCallback;
this._globalOptions.breadcrumbCallback = keepOriginalCallback(original, callback);
return this;
},

/*
* Set the shouldSendCallback option
*
* @param {function} callback The callback to run which allows
* introspecting the blob before sending
* @return {Raven}
*/
setShouldSendCallback: function(callback) {
var original = this._globalOptions.shouldSendCallback;
this._globalOptions.shouldSendCallback = keepOriginalCallback(original, callback);
return this;
},

/**

Override the default HTTP transport mechanism that transmits data
to the Sentry server.
@param {function} transport Function invoked instead of the default

                        `makeRequest` handler.

@return {Raven}
*/
setTransport: function(transport) {
this._globalOptions.transport = transport;

return this;

},

/*
* Get the latest raw exception that was captured by Raven.
*
* @return {error}
*/
lastException: function() {
return this._lastCapturedException;
},

/*
* Get the last event id
*
* @return {string}
*/
lastEventId: function() {
return this._lastEventId;
},

/*
* Determine if Raven is setup and ready to go.
*
* @return {boolean}
*/
isSetup: function() {
if (!this._hasJSON) return false; // needs JSON support
if (!this._globalServer) {
if (!this.ravenNotConfiguredError) {
this.ravenNotConfiguredError = true;
this._logDebug('error', 'Error: Raven has not been configured.');
}
return false;
}
return true;
},

afterLoad: function() {
// TODO: remove window dependence?

// Attempt to initialize Raven on load
var RavenConfig = _window.RavenConfig;
if (RavenConfig) {
  this.config(RavenConfig.dsn, RavenConfig.config).install();
}

},

showReportDialog: function(options) {
if (
!_document // doesn't work without a document (React native)
)
return;

options = objectMerge(

[[getLinesNotShownLabel_( truncatedAfter_, '', '')]]`

The text was updated successfully, but these errors were encountered:

lucksin3 · 2022-11-14T16:16:59Z

This issue is resolved in the latest version released on Chrome store- Please upgrade to version 6.2.12

lucksin3 closed this as completed Nov 14, 2022

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

White Error XDCpay #14

White Error XDCpay #14

xcantera commented Sep 13, 2022

lucksin3 commented Nov 14, 2022

White Error XDCpay #14

White Error XDCpay #14

Comments

xcantera commented Sep 13, 2022

lucksin3 commented Nov 14, 2022