@payburner/payburner-payid-client-core
Version:
Models library for Core Payburner
242 lines • 12.2 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PayIDClient = void 0;
const axios_1 = __importDefault(require("axios"));
const ParsedPayID_1 = require("../model/ParsedPayID");
const ResolvedPayID_1 = require("../model/impl/ResolvedPayID");
const ResolvedAddress_1 = require("../model/impl/ResolvedAddress");
const AddressDetailsType_1 = require("../model/interfaces/AddressDetailsType");
const ResolvedCryptoAddressDetails_1 = require("../model/impl/ResolvedCryptoAddressDetails");
const ResolvedAchAddressDetails_1 = require("../model/impl/ResolvedAchAddressDetails");
const PayIDAddressTypes_1 = require("../model/types/PayIDAddressTypes");
const PayIDHeader_1 = require("../model/types/PayIDHeader");
const VerifiedPayIDUtils_1 = require("./VerifiedPayIDUtils");
class PayIDClient {
constructor(tolerant = true, payIDThumbprintServiceLookup) {
this.tolerant = tolerant;
this.verifiedPayIDUtils = new VerifiedPayIDUtils_1.VerifiedPayIDUtils();
if (typeof payIDThumbprintServiceLookup !== 'undefined') {
this.payIDThumbprintServiceLookup = payIDThumbprintServiceLookup;
}
}
isASCII(input) {
return /^[\x00-\x7F]*$/u.test(input);
}
parsePayIDUri(payId) {
if (!this.isASCII(payId)) {
return undefined;
}
const lastDollarIndex = payId.lastIndexOf('$');
if (lastDollarIndex === -1) {
return undefined;
}
const path = payId.slice(0, lastDollarIndex);
const host = payId.slice(lastDollarIndex + 1);
if (host.length === 0 || path.length === 0) {
return undefined;
}
return new ParsedPayID_1.ParsedPayID(host, path);
}
resolveRawPayID(payID, payIDHeader) {
const parsedPayID = this.parsePayIDUri(payID);
return new Promise((resolve, reject) => {
if (typeof parsedPayID === 'undefined') {
reject({ error: 'unparseable payid' });
return;
}
axios_1.default.get('https://' + parsedPayID.host + '/' + parsedPayID.path, {
headers: {
'Accept': (typeof payIDHeader === 'undefined' ? PayIDHeader_1.PayIDHeader.ALL : payIDHeader),
'PayID-Version': '1.0'
}
})
.then((response) => {
resolve(response.data);
}).catch((error) => {
resolve(error);
});
});
}
parsePayIDFromData(data) {
const self = this;
return new Promise((resolve, reject) => {
if (typeof data.addresses === 'undefined') {
const errorMsg = 'Problem resolving the payId -- missing address segment';
reject({ error: errorMsg });
}
const addresses = new Array();
const verifiedAddresses = new Array();
data.addresses.forEach((address) => {
const addressDetailsType = address.addressDetailsType;
const addressDetails = address.addressDetails;
let addressDetailsTypeVal = null;
if (typeof addressDetails === undefined) {
console.log('address is missing address details. skipping');
return;
}
if (typeof addressDetailsType === undefined) {
if (!self.tolerant) {
console.log('address is missing addressDetailsType and we are intolerant. skipping');
return;
}
if (typeof addressDetails.address !== undefined) {
addressDetailsTypeVal = AddressDetailsType_1.AddressDetailsType.CryptoAddress;
}
else if (typeof addressDetails.routingNumber !== undefined && typeof addressDetails.accountNumber !== undefined) {
addressDetailsTypeVal = AddressDetailsType_1.AddressDetailsType.AchAddress;
}
}
else {
if (addressDetailsType === AddressDetailsType_1.AddressDetailsType.CryptoAddress) {
if (typeof addressDetails.address !== undefined) {
addressDetailsTypeVal = AddressDetailsType_1.AddressDetailsType.CryptoAddress;
}
}
else if (addressDetailsType === AddressDetailsType_1.AddressDetailsType.AchAddress) {
if (typeof addressDetails.routingNumber !== undefined && typeof addressDetails.accountNumber !== undefined) {
addressDetailsTypeVal = AddressDetailsType_1.AddressDetailsType.AchAddress;
}
}
}
if (addressDetailsTypeVal === null) {
console.log('Unknown address details type. skipping');
return;
}
const paymentNetwork = address.paymentNetwork;
if (typeof paymentNetwork === undefined) {
console.log('address is missing paymentNetwork');
return;
}
let addressDetailsVal = null;
if (addressDetailsTypeVal === AddressDetailsType_1.AddressDetailsType.CryptoAddress) {
addressDetailsVal = new ResolvedCryptoAddressDetails_1.ResolvedCryptoAddressDetails(addressDetails.address, addressDetails.tag);
}
else {
addressDetailsVal = new ResolvedAchAddressDetails_1.ResolvedAchAddressDetails(addressDetails.routingNumber, addressDetails.accountNumber);
}
const environment = address.environment;
addresses.push(new ResolvedAddress_1.ResolvedAddress(addressDetailsVal, addressDetailsTypeVal, paymentNetwork, environment));
});
if (typeof data.verifiedAddresses !== 'undefined') {
data.verifiedAddresses.forEach((verifiedAddress) => {
verifiedAddresses.push(verifiedAddress);
});
}
resolve(new ResolvedPayID_1.ResolvedPayID(addresses, data.payId, undefined, undefined, verifiedAddresses.length > 0 ? verifiedAddresses : undefined));
});
}
validateResolvedPayID(payID, data, verify) {
const self = this;
return new Promise((resolve, reject) => {
if (typeof data.payId === 'undefined') {
reject('The resolved PayID does not have a payID field');
}
else if (!payID.startsWith(data.payId)) {
const errorMsg = 'Problem resolving the payId -- the record returned does not match the request';
console.log(errorMsg);
if (!self.tolerant) {
reject({ error: errorMsg });
return;
}
}
self.parsePayIDFromData(data).then((resolvedPayId) => __awaiter(this, void 0, void 0, function* () {
if ((typeof resolvedPayId.verifiedAddresses === 'undefined'
|| resolvedPayId.verifiedAddresses === null || resolvedPayId.verifiedAddresses.length === 0)) {
console.log('No verified addresses presented so we are returning OK');
resolve(resolvedPayId);
}
else if (verify) {
console.log('Verify set to true, so let us verify');
if (typeof self.payIDThumbprintServiceLookup !== 'undefined') {
self.payIDThumbprintServiceLookup.resolvePayIDThumbprint(payID).then((thumbprint) => __awaiter(this, void 0, void 0, function* () {
console.log('Calling the verifyPayID Method with thumbprint:' + thumbprint.thumbprint);
const verificationResult = yield self.verifiedPayIDUtils.verifyPayID(thumbprint.thumbprint, resolvedPayId);
console.log('Verification result returned from verifyPayID method:' + JSON.stringify(verificationResult));
if (!verificationResult.verified) {
reject(verificationResult.errorMessage);
}
else {
if (typeof resolvedPayId.verifiedAddresses !== 'undefined' && resolvedPayId.verifiedAddresses !== null) {
resolvedPayId.addresses = new Array();
resolvedPayId.verifiedAddresses.forEach((verifiedAddress) => {
resolvedPayId.addresses.push(JSON.parse(verifiedAddress.payload).payIdAddress);
});
}
resolve(resolvedPayId);
}
})).catch((error) => {
reject('Error resolving thumbprint of public key for verified payID');
});
}
else {
reject('You requested a verification, but provided no lookup service');
}
}
else {
resolve(resolvedPayId);
}
})).catch((error) => {
reject(error);
});
});
}
resolvePayID(payID, verify = false) {
const self = this;
return new Promise((resolve, reject) => {
self.resolveRawPayID(payID).then((data) => {
self.validateResolvedPayID(payID, data, verify).then((resolvedPayID) => {
console.log('Validation Result:' + JSON.stringify(resolvedPayID, null, 2));
resolve(resolvedPayID);
}).catch((error) => {
reject(error);
});
}).catch((error) => {
reject(error);
});
});
}
resolvePayIDAddressWithThumbprint(payID, paymentNetwork, environment) {
const self = this;
return new Promise((resolve, reject) => {
self.resolveRawPayID(payID).then((data) => {
self.verifiedPayIDUtils.getResolvedCryptoAddressWithThumbprint(data, paymentNetwork, environment)
.then((response) => {
resolve(response);
});
}).catch((error) => {
reject(error);
});
});
}
seekAddressOfType(resolvedPayID, payIdAddressType) {
const addresses = resolvedPayID.addresses.filter((address) => {
if (address.paymentNetwork.toLowerCase() === payIdAddressType.network.toLowerCase()) {
if (typeof address.environment !== 'undefined' && address.environment === payIdAddressType.environment) {
return true;
}
}
return false;
});
if (addresses.length > 0) {
return addresses[0];
}
return undefined;
}
getPayIDAddressTypes() {
return new PayIDAddressTypes_1.PayIDAddressTypes();
}
}
exports.PayIDClient = PayIDClient;
//# sourceMappingURL=PayIDClient.js.map