@staxpayments/staxpayments-js 2.30.18

package/src/cryptoutils.js

@@ -0,0 +1,95 @@
+var { hmac } = require('@noble/hashes/hmac')
+var { sha256 } = require('@noble/hashes/sha256')
+var { randomBytes, bytesToHex, utf8ToBytes } = require('@noble/hashes/utils')
+var { p256 } = require('@noble/curves/nist')
+var moment = require('moment')
+var base32 = require('base32')
+var aesjs = require('aes-js')
+
+export class BlockChypCrypto {
+  generateGatewayHeaders (creds) {
+    let nonce = this.generateNonce()
+    let ts = this.generateIsoTimestamp()
+    let toSign = creds.apiKey + creds.bearerToken + ts + nonce
+    let key = Buffer.from(creds.signingKey, 'hex')
+    let mac = hmac(sha256, key, utf8ToBytes(toSign))
+    let sig = bytesToHex(mac)
+
+    var results = {
+      'Nonce': nonce,
+      'Timestamp': ts,
+      'Authorization': 'Dual ' + creds.bearerToken + ':' + creds.apiKey + ':' + sig
+    }
+
+    return results
+  }
+
+  encrypt (hexKey, plainText) {
+    let key = Buffer.from(hexKey, 'hex').slice(0, 32)
+    let keyArr = [...key]
+
+    let iv = randomBytes(16)
+    let ivArr = [...iv]
+
+    let aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, ivArr)
+    let plainBytes = aesjs.padding.pkcs7.pad(aesjs.utils.utf8.toBytes(plainText))
+    let encryptedBytes = aesCbc.encrypt(plainBytes)
+
+    return bytesToHex(iv) + aesjs.utils.hex.fromBytes(encryptedBytes)
+  }
+
+  sha256Hash (msg) {
+    let msgBytes = Buffer.from(msg, 'hex')
+    return bytesToHex(sha256(msgBytes))
+  }
+
+  validateSignature (publicKey, msg, sig) {
+    // Hash the message
+    let msgHash = this.sha256Hash(msg)
+    let msgHashBytes = Buffer.from(msgHash, 'hex')
+
+    // Convert hex string coordinates to BigInt and create point
+    let pubKeyPoint = p256.ProjectivePoint.fromAffine({
+      x: BigInt('0x' + publicKey.x),
+      y: BigInt('0x' + publicKey.y)
+    })
+    let pubKeyBytes = pubKeyPoint.toRawBytes(false)
+
+    // Create signature from r, s components
+    let signature = new p256.Signature(
+      BigInt('0x' + sig.r),
+      BigInt('0x' + sig.s)
+    )
+    let sigBytes = signature.toCompactRawBytes()
+
+    // Verify signature
+    return p256.verify(sigBytes, msgHashBytes, pubKeyBytes, { prehash: true })
+  }
+
+  decrypt (hexKey, cipherText) {
+    let key = Buffer.from(hexKey, 'hex').slice(0, 32)
+    let keyArr = [...key]
+
+    let cipherBytes = Buffer.from(cipherText, 'hex')
+    let iv = cipherBytes.slice(0, 16)
+
+    var aesCbc = new aesjs.ModeOfOperation.cbc(keyArr, iv)
+
+    let cipher = cipherBytes.slice(16, cipherBytes.length)
+    let cipherArr = [...cipher]
+    let decryptedBytes = aesjs.padding.pkcs7.strip(aesCbc.decrypt(cipherArr))
+
+    return aesjs.utils.utf8.fromBytes(decryptedBytes)
+  }
+
+  generateNonce () {
+    return base32.encode(randomBytes(32)).toUpperCase()
+  }
+
+  generateIsoTimestamp () {
+    return moment().utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
+  }
+}
+
+var CryptoUtils = new BlockChypCrypto()
+export default CryptoUtils

package/src/global.js

@@ -0,0 +1,6 @@
+import * as base from './client'
+import * as root from './staxpaymentsclient'
+
+if (typeof window !== 'undefined') {
+  window.staxpayments = { ...base, ...root }
+}

package/src/mappers.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+
+/**
+ * Maps a Stax Payments charge or preauth request onto the BlockChyp wire model. Fields not
+ * listed here carry the same name on both sides and are matched by name; the generated
+ * mapper spells every one of them out.
+ */
+export function authRequestMapper (src) {
+  let dst = {}
+
+  dst.tipAmount = src.tipAmount
+  dst.taxAmount = src.taxAmount
+  dst.terminalName = src.terminalName
+  dst.amount = src.amount
+  dst.currencyCode = src.currencyCode
+  dst.promptForTip = src.promptForTip
+  dst.test = src.test
+  dst.enroll = src.enroll
+  dst.externalPartnerMetadata = src.externalPartnerMetadata
+  /**
+   * The caller's own reference rides out as externalTransactionRef. BlockChyp's own
+   * transactionRef is a different thing: it drives duplicate detection and transaction
+   * recall, and carries the Stax transaction id.
+   */
+  dst.externalTransactionRef = src.transactionRef
+
+  return dst
+}
+
+/**
+ * Maps a BlockChyp charge or preauth response onto the Stax Payments model. Fields not
+ * listed here are matched by name.
+ */
+export function authResponseMapper (src) {
+  let dst = {}
+
+  dst.success = src.success
+  dst.error = src.error
+  dst.responseDescription = src.responseDescription
+  /**
+   * The Stax transaction id comes back in the transaction ref. BlockChyp's
+   * transactionId is BlockChyp's own id and is deliberately not surfaced.
+   */
+  dst.transactionId = src.transactionRef
+  dst.approved = src.approved
+  dst.authCode = src.authCode
+  dst.requestedAmount = src.requestedAmount
+  dst.authorizedAmount = src.authorizedAmount
+  dst.currencyCode = src.currencyCode
+  dst.entryMethod = src.entryMethod
+  dst.maskedPan = src.maskedPan
+  dst.network = src.network
+  dst.timestamp = src.timestamp
+  dst.status = src.status
+  dst.cardMetadata = src.cardMetadata
+  dst.receiptSuggestions = src.receiptSuggestions
+  dst.test = src.test
+  /**
+   * The caller's own reference comes back from externalTransactionRef, not from
+   * BlockChyp's transactionRef, which carries the Stax transaction id and is surfaced
+   * as transactionId.
+   */
+  dst.transactionRef = src.externalTransactionRef
+
+  return dst
+}

package/src/payments.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+import * as Mappers from './mappers'
+
+// PaymentsClient exposes the Payment Endpoints for the Stax Payments
+// API. It is constructed by the root StaxPaymentsClient with a shared transport
+// (StaxPaymentsBaseClient), so every namespace shares one transient-credential
+// cache rather than exchanging credentials per namespace.
+export class PaymentsClient {
+  constructor (base) {
+    this.base = base
+  }
+
+  /**
+   * Executes a standard direct preauth and capture.
+   */
+  // Takes and returns the Stax Payments models. The BlockChyp wire models are
+  // an implementation detail: the request is mapped on the way out and the
+  // reply on the way back.
+  async charge (request) {
+    let response = await this.base.routeTransaction('post', Mappers.authRequestMapper(request), '/api/charge', '/api/charge')
+
+    return Mappers.authResponseMapper(response.data)
+  }
+  /**
+   * Executes a preauthorization intended to be captured later.
+   */
+  // Takes and returns the Stax Payments models. The BlockChyp wire models are
+  // an implementation detail: the request is mapped on the way out and the
+  // reply on the way back.
+  async preauth (request) {
+    let response = await this.base.routeTransaction('post', Mappers.authRequestMapper(request), '/api/preauth', '/api/preauth')
+
+    return Mappers.authResponseMapper(response.data)
+  }
+}

package/src/staxpaymentsclient.js

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+import {StaxPaymentsBaseClient} from './client'
+import {PaymentsClient} from './payments'
+import {TerminalsClient} from './terminals'
+
+// StaxPaymentsClient is the root Stax Payments client. It builds the shared
+// transport (StaxPaymentsBaseClient) once and exposes each API namespace
+// (e.g. payments, terminals) as a property, so a single set of transient
+// credentials is fetched, cached, and refreshed across every namespace rather
+// than per namespace.
+export class StaxPaymentsClient {
+  // Construct the root client with your Stax bearer token.
+  constructor (creds, opts = {}) {
+    this.base = new StaxPaymentsBaseClient(creds, opts)
+    this.payments = new PaymentsClient(this.base)
+    this.terminals = new TerminalsClient(this.base)
+  }
+
+  // heartbeat checks connectivity with the Stax Payments gateway.
+  heartbeat () {
+    return this.base.heartbeat()
+  }
+
+  // Host configuration is shared across every namespace.
+  setGatewayHost (host) {
+    this.base.setGatewayHost(host)
+  }
+
+  getGatewayHost () {
+    return this.base.getGatewayHost()
+  }
+
+  setTestGatewayHost (host) {
+    this.base.setTestGatewayHost(host)
+  }
+
+  setDashboardHost (host) {
+    this.base.setDashboardHost(host)
+  }
+
+  getDashboardHost () {
+    return this.base.getDashboardHost()
+  }
+
+  setCoreHost (host) {
+    this.base.setCoreHost(host)
+  }
+}

package/src/terminals.js

@@ -0,0 +1,104 @@
+/**
+ * Copyright 2019-2026 BlockChyp, Inc. All rights reserved. Use of this code is governed
+ * by a license that can be found in the LICENSE file.
+ *
+ * This file was generated automatically by the BlockChyp SDK Generator. Changes to this
+ * file will be lost every time the code is regenerated.
+ */
+
+// TerminalsClient exposes the Terminal Management Endpoints for the Stax Payments
+// API. It is constructed by the root StaxPaymentsClient with a shared transport
+// (StaxPaymentsBaseClient), so every namespace shares one transient-credential
+// cache rather than exchanging credentials per namespace.
+export class TerminalsClient {
+  constructor (base) {
+    this.base = base
+  }
+
+  /**
+   * Tests connectivity with a payment terminal.
+   */
+  async ping (request) {
+    return this.base.routeTransaction('post', request, '/api/test', '/api/terminal-test')
+  }
+  /**
+   * Returns routing and location data for a payment terminal.
+   */
+  locate (request) {
+    return this.base._gatewayRequest('post', '/api/terminal-locate', request)
+  }
+  /**
+   * Clears the line item display and any in progress transaction.
+   */
+  async clear (request) {
+    return this.base.routeTransaction('post', request, '/api/clear', '/api/terminal-clear')
+  }
+  /**
+   * Returns the current status of a terminal.
+   */
+  async terminalStatus (request) {
+    return this.base.routeTransaction('post', request, '/api/terminal-status', '/api/terminal-status')
+  }
+  /**
+   * Captures and returns a signature.
+   */
+  async captureSignature (request) {
+    return this.base.routeTransaction('post', request, '/api/capture-signature', '/api/capture-signature')
+  }
+  /**
+   * Displays a new transaction on the terminal.
+   */
+  async newTransactionDisplay (request) {
+    return this.base.routeTransaction('post', request, '/api/txdisplay', '/api/terminal-txdisplay')
+  }
+  /**
+   * Appends items to an existing transaction display. Subtotal, Tax, and Total are
+   * overwritten by the request. Items with the same description are combined into
+   * groups.
+   */
+  async updateTransactionDisplay (request) {
+    return this.base.routeTransaction('put', request, '/api/txdisplay', '/api/terminal-txdisplay')
+  }
+  /**
+   * Displays a short message on the terminal.
+   */
+  async message (request) {
+    return this.base.routeTransaction('post', request, '/api/message', '/api/message')
+  }
+  /**
+   * Asks the consumer a yes/no question.
+   */
+  async booleanPrompt (request) {
+    return this.base.routeTransaction('post', request, '/api/boolean-prompt', '/api/boolean-prompt')
+  }
+  /**
+   * Asks the consumer a text based question.
+   */
+  async textPrompt (request) {
+    return this.base.routeTransaction('post', request, '/api/text-prompt', '/api/text-prompt')
+  }
+  /**
+   * Returns all terminals associated with the merchant account.
+   */
+  terminals (request) {
+    return this.base._dashboardRequest('get', '/api/terminals', request)
+  }
+  /**
+   * Deactivates a terminal.
+   */
+  deactivateTerminal (request) {
+    return this.base._dashboardRequest('delete', '/api/terminal/' + request.terminalId, request)
+  }
+  /**
+   * Activates a terminal.
+   */
+  async activateTerminal (request) {
+    return this.base._coreRequest('post', '/terminals', request)
+  }
+  /**
+   * Reboot a payment terminal.
+   */
+  async reboot (request) {
+    return this.base.routeTransaction('post', request, '/api/reboot', '/api/terminal-reboot')
+  }
+}