384 lines
10 KiB
JavaScript
384 lines
10 KiB
JavaScript
|
|
const _ = require('lodash/fp')
|
|
|
|
const axios = require('axios')
|
|
const NAME = 'LN'
|
|
const SUPPORTED_COINS = ['LN', 'BTC']
|
|
const PHONE = '+3500000000000'
|
|
const TEST_AUTH_TOKEN = ''
|
|
|
|
const URI = 'https://api.staging.galoy.io/graphql'
|
|
|
|
const BN = require('../../../bn')
|
|
|
|
function request (graphqlQuery, token) {
|
|
const headers = {
|
|
'content-type': 'application/json',
|
|
'Authorization': `Bearer ${token || TEST_AUTH_TOKEN}`
|
|
}
|
|
return Promise.resolve(true)
|
|
.then(() => {
|
|
return axios({
|
|
method: 'post',
|
|
url: URI,
|
|
headers: headers,
|
|
data: graphqlQuery
|
|
})
|
|
})
|
|
.then(r => {
|
|
if (r.error) throw r.error
|
|
return r.data
|
|
})
|
|
.catch(err => {
|
|
throw new Error(err)
|
|
})
|
|
}
|
|
|
|
function checkCryptoCode (cryptoCode) {
|
|
if (!SUPPORTED_COINS.includes(cryptoCode)) {
|
|
return Promise.reject(new Error('Unsupported crypto: ' + cryptoCode))
|
|
}
|
|
|
|
return Promise.resolve()
|
|
}
|
|
|
|
function getGaloyAccount (token) {
|
|
const accountInfo = {
|
|
'operationName': 'me',
|
|
'query': `query me {
|
|
me {
|
|
createdAt
|
|
defaultAccount {
|
|
defaultWalletId
|
|
wallets {
|
|
id
|
|
walletCurrency
|
|
balance
|
|
transactions {
|
|
edges {
|
|
node {
|
|
createdAt
|
|
direction
|
|
id
|
|
settlementAmount
|
|
settlementFee
|
|
status
|
|
initiationVia {
|
|
... on InitiationViaIntraLedger {
|
|
counterPartyUsername
|
|
counterPartyWalletId
|
|
}
|
|
... on InitiationViaLn {
|
|
paymentHash
|
|
}
|
|
... on InitiationViaOnChain {
|
|
address
|
|
}
|
|
}
|
|
settlementVia {
|
|
... on SettlementViaIntraLedger {
|
|
counterPartyUsername
|
|
counterPartyWalletId
|
|
}
|
|
... on SettlementViaLn {
|
|
preImage
|
|
}
|
|
... on SettlementViaOnChain {
|
|
transactionHash
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
id
|
|
phone
|
|
twoFAEnabled
|
|
username
|
|
}
|
|
}`,
|
|
'variables': {}
|
|
}
|
|
return request(accountInfo, token)
|
|
.then(r => {
|
|
return r.data.me.defaultAccount
|
|
})
|
|
.catch(err => {
|
|
throw new Error(err)
|
|
})
|
|
}
|
|
|
|
function fetchAuthToken (config) {
|
|
const phone = config.phone
|
|
// userRequestAuthCode deprecated?
|
|
const regularRequestAuthCode = {
|
|
'operationName': 'userRequestAuthCode',
|
|
'query': `mutation userRequestAuthCode($input: UserRequestAuthCodeInput!) {
|
|
userRequestAuthCode(input: $input) {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
success
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'phone': `${phone}` } }
|
|
}
|
|
const createCaptcha = {
|
|
'operationName': 'captchaCreateChallenge',
|
|
'query': `mutation captchaCreateChallenge {
|
|
captchaCreateChallenge {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
result {
|
|
challengeCode
|
|
id
|
|
}
|
|
}
|
|
}`,
|
|
'variables': {}
|
|
}
|
|
const captchaRequestAuthCode = code => ({
|
|
'operationName': 'captchaRequestAuthCode',
|
|
'query': `mutation captchaRequestAuthCode($input: CaptchaRequestAuthCodeInput!) {
|
|
captchaRequestAuthCode(input: $input) {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
success
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'phone': `${phone}`, 'challengeCode': `${code.challengeCode}`, 'secCode': `${code.challengeCode.slice(0, 5)}`, 'validationCode': `${code.challengeCode.slice(0, 5)}` } }
|
|
})
|
|
|
|
return request(createCaptcha)
|
|
.then(r => {
|
|
const code = r.data.captchaCreateChallenge.result
|
|
if (code) {
|
|
// captchaRequestAuthCode parameters have to be processed by geetest
|
|
return request(captchaRequestAuthCode(code))
|
|
}
|
|
})
|
|
.catch(err => {
|
|
throw new Error(err)
|
|
})
|
|
}
|
|
|
|
function isLightning (address) {
|
|
return address.substr(0, 2) === 'ln'
|
|
}
|
|
|
|
function sendFundsOnChain (walletId, address, cryptoAtoms, token) {
|
|
const sendOnChain = {
|
|
'operationName': 'onChainPaymentSend',
|
|
'query': `mutation onChainPaymentSend($input: OnChainPaymentSendInput!) {
|
|
onChainPaymentSend(input: $input) {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
status
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'address': `${address}`, 'amount': `${cryptoAtoms}`, 'walletId': `${walletId}` } }
|
|
}
|
|
return request(sendOnChain, token)
|
|
.then(result => {
|
|
return result.data.onChainPaymentSend
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function sendFundsLN (walletId, invoice, token) {
|
|
const sendLN = {
|
|
'operationName': 'lnInvoicePaymentSend',
|
|
'query': `mutation lnInvoicePaymentSend($input: LnInvoicePaymentInput!) {
|
|
lnInvoicePaymentSend(input: $input) {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
status
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'paymentRequest': `${invoice}`, 'walletId': `${walletId}` } }
|
|
}
|
|
return request(sendLN, token)
|
|
.then(result => {
|
|
return result.data.onChainPaymentSend
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function sendCoins (account, tx, settings, operatorId) {
|
|
const { toAddress, cryptoAtoms, cryptoCode } = tx
|
|
return checkCryptoCode(cryptoCode)
|
|
// .then(() => fetchAuthToken({ phone: PHONE }))
|
|
.then(authToken => Promise.all([getGaloyAccount(authToken), authToken]))
|
|
.then(([account, authToken]) => {
|
|
const wallet = _.head(_.filter(wallet => wallet.walletCurrency === cryptoCode && wallet.id === account.defaultWalletId)(account.wallets))
|
|
if (isLightning(toAddress)) {
|
|
return sendFundsLN(wallet.id, toAddress, authToken)
|
|
}
|
|
return sendFundsOnChain(wallet.id, toAddress, cryptoAtoms, authToken)
|
|
})
|
|
.then(result => {
|
|
return result
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function newOnChainAddress (walletId, token) {
|
|
const createOnChainAddress = {
|
|
'operationName': 'onChainAddressCreate',
|
|
'query': `mutation onChainAddressCreate($input: OnChainAddressCreateInput!) {
|
|
onChainAddressCreate(input: $input) {
|
|
address
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'walletId': `${walletId}` } }
|
|
}
|
|
return request(createOnChainAddress, token)
|
|
.then(result => {
|
|
return result.data.onChainAddressCreate.address
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function newInvoice (walletId, cryptoAtoms, token) {
|
|
const createInvoice = {
|
|
'operationName': 'lnInvoiceCreate',
|
|
'query': `mutation lnInvoiceCreate($input: LnInvoiceCreateInput!) {
|
|
lnInvoiceCreate(input: $input) {
|
|
errors {
|
|
message
|
|
path
|
|
}
|
|
invoice {
|
|
paymentRequest
|
|
}
|
|
}
|
|
}`,
|
|
'variables': { 'input': { 'walletId': `${walletId}`, 'amount': `${cryptoAtoms}` } }
|
|
}
|
|
return request(createInvoice, token)
|
|
.then(result => {
|
|
return result.data.lnInvoiceCreate.invoice.paymentRequest
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function balance (account, cryptoCode, settings, operatorId) {
|
|
return checkCryptoCode(cryptoCode)
|
|
// .then(() => fetchAuthToken({ phone: PHONE }))
|
|
.then(authToken => getGaloyAccount(authToken))
|
|
.then(account => {
|
|
console.log(account)
|
|
// account has a list of wallets, should we consider the balance of each one?
|
|
// for now we'll pick the first BTC wallet that matches the defaultWalletId
|
|
const wallet = _.head(_.filter(wallet => wallet.walletCurrency === cryptoCode && wallet.id === account.defaultWalletId)(account.wallets))
|
|
console.log(wallet)
|
|
return new BN(wallet.balance || 0)
|
|
})
|
|
.catch(err => {
|
|
throw err
|
|
})
|
|
}
|
|
|
|
function newAddress (account, info, tx, settings, operatorId) {
|
|
const { cryptoAtoms, cryptoCode } = tx
|
|
return checkCryptoCode(cryptoCode)
|
|
// .then(() => fetchAuthToken({ phone: PHONE }))
|
|
.then(authToken => Promise.all([getGaloyAccount(authToken), authToken]))
|
|
.then(([account, authToken]) => {
|
|
const wallet = _.head(_.filter(wallet => wallet.walletCurrency === cryptoCode && wallet.id === account.defaultWalletId)(account.wallets))
|
|
const promises = [
|
|
newOnChainAddress(wallet.id, authToken),
|
|
newInvoice(wallet.id, cryptoAtoms, authToken)
|
|
]
|
|
return Promise.all(promises)
|
|
})
|
|
.then(([onChainAddress, invoice]) => {
|
|
return `bitcoin:${onChainAddress}?amount=${cryptoAtoms}?lightning=${invoice}`
|
|
})
|
|
}
|
|
|
|
function getStatus (account, tx, requested, settings, operatorId) {
|
|
// Type Transaction has a field status
|
|
// but we're not sure if it's interchangeable with our status definition
|
|
}
|
|
|
|
function newFunding (account, cryptoCode, settings, operatorId) {
|
|
// Has to be a regular BTC address
|
|
return checkCryptoCode(cryptoCode)
|
|
// .then(() => fetchAuthToken({ phone: PHONE }))
|
|
.then(authToken => [getGaloyAccount(authToken), authToken])
|
|
.then(([account, authToken]) => {
|
|
const wallet = _.filter(wallet => wallet.walletCurrency === cryptoCode && wallet.id === account.defaultWalletId)(account.wallets)
|
|
return newOnChainAddress(wallet.id, authToken)
|
|
.then(onChainAddress => [onChainAddress, wallet.balance])
|
|
})
|
|
.then(([onChainAddress, balance]) => {
|
|
// Missing pending balance
|
|
return {
|
|
fundingConfirmedBalance: new BN(balance),
|
|
fundingAddress: onChainAddress
|
|
}
|
|
})
|
|
}
|
|
|
|
function cryptoNetwork (account, cryptoCode, settings, operatorId) {
|
|
return checkCryptoCode(cryptoCode)
|
|
.then(() => account.environment === 'test' ? 'test' : 'main')
|
|
}
|
|
|
|
function checkBlockchainStatus (cryptoCode) {
|
|
return checkCryptoCode(cryptoCode)
|
|
.then(() => Promise.resolve('ready'))
|
|
}
|
|
|
|
// sendCoins({}, {
|
|
// toAddress: 'tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt',
|
|
// cryptoCode: 'BTC',
|
|
// cryptoAtoms: 1000
|
|
// }, {}, {})
|
|
// .then(r => console.log(r))
|
|
|
|
// balance({}, 'BTC', {}, {})
|
|
// .then(r => console.log())
|
|
// getGaloyAccount()
|
|
// newAddress({}, {}, { cryptoCode: 'BTC', cryptoAtoms: 1 }, {})
|
|
// .then(r => console.log(r))
|
|
|
|
// Test faucet addresses
|
|
// tb1qfyt7cgds7z8ssthtnhh35s608059yzk0hwgcqd 1)
|
|
// tb1qmflph389nz5ev05jypzvcglyguyrl2qhyaag6r 2)
|
|
|
|
module.exports = {
|
|
NAME,
|
|
balance,
|
|
sendCoins,
|
|
newAddress,
|
|
getStatus,
|
|
newFunding,
|
|
cryptoNetwork,
|
|
checkBlockchainStatus
|
|
}
|