Martien/n8n-nodes-strike
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: n8n Strike API node

Browse Source 
- Add Strike API credentials configuration
- Implement Strike node with 9 resources (Account, Balance, Currency Exchange, Deposit, Invoice, Payment, Payment Method, Payout, Rates)
- Add comprehensive operation descriptions for all resources
- Include CLAUDE.MD documentation
- Set up build configuration with TypeScript, ESLint, and Prettier

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Martien
2025-12-10 11:00:38 +01:00
commit 5605b9b49a
8925 changed files with 1417728 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
dist/credentials/StrikeApi.credentials.d.ts vendored Normal file
View File

@ -0,0 +1,9 @@
import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
export declare class StrikeApi implements ICredentialType {
name: string;
displayName: string;
documentationUrl: string;
properties: INodeProperties[];
authenticate: IAuthenticateGeneric;
test: ICredentialTestRequest;
}

53
dist/credentials/StrikeApi.credentials.js vendored Normal file
View File

@ -0,0 +1,53 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.StrikeApi = void 0;
class StrikeApi {
constructor() {
this.name = 'strikeApi';
this.displayName = 'Strike API';
this.documentationUrl = 'https://docs.strike.me/api/';
this.properties = [
{
displayName: 'API Key',
name: 'apiKey',
type: 'string',
typeOptions: { password: true },
default: '',
required: true,
description: 'Your Strike API key from the Strike Dashboard',
},
{
displayName: 'Environment',
name: 'environment',
type: 'options',
options: [
{
name: 'Production',
value: 'production',
},
{
name: 'Sandbox',
value: 'sandbox',
},
],
default: 'production',
description: 'Select the Strike API environment',
},
];
this.authenticate = {
type: 'generic',
properties: {
headers: {
Authorization: '={{"Bearer " + $credentials.apiKey}}',
},
},
};
this.test = {
request: {
baseURL: '={{$credentials.environment === "sandbox" ? "https://api.strike.me" : "https://api.strike.me"}}',
url: '/v1/balances',
},
};
}
}
exports.StrikeApi = StrikeApi;

5
dist/nodes/Strike/Strike.node.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
export declare class Strike implements INodeType {
description: INodeTypeDescription;
execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
}

448
dist/nodes/Strike/Strike.node.js vendored Normal file
View File

@ -0,0 +1,448 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Strike = void 0;
const StrikeApi_1 = require("./StrikeApi");
const descriptions_1 = require("./descriptions");
class Strike {
constructor() {
this.description = {
displayName: 'Strike',
name: 'strike',
icon: 'file:strike.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Interact with Strike API for Bitcoin and Lightning payments',
defaults: {
name: 'Strike',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'strikeApi',
required: true,
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Account',
value: 'account',
},
{
name: 'Balance',
value: 'balance',
},
{
name: 'Currency Exchange',
value: 'currencyExchange',
},
{
name: 'Deposit',
value: 'deposit',
},
{
name: 'Invoice',
value: 'invoice',
},
{
name: 'Payment',
value: 'payment',
},
{
name: 'Payment Method',
value: 'paymentMethod',
},
{
name: 'Payout',
value: 'payout',
},
{
name: 'Rates',
value: 'rates',
},
],
default: 'balance',
},
// Operations and fields for each resource
...descriptions_1.accountOperations,
...descriptions_1.accountFields,
...descriptions_1.balanceOperations,
...descriptions_1.balanceFields,
...descriptions_1.currencyExchangeOperations,
...descriptions_1.currencyExchangeFields,
...descriptions_1.depositOperations,
...descriptions_1.depositFields,
...descriptions_1.invoiceOperations,
...descriptions_1.invoiceFields,
...descriptions_1.paymentOperations,
...descriptions_1.paymentFields,
...descriptions_1.paymentMethodOperations,
...descriptions_1.paymentMethodFields,
...descriptions_1.payoutOperations,
...descriptions_1.payoutFields,
...descriptions_1.ratesOperations,
...descriptions_1.ratesFields,
],
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
const resource = this.getNodeParameter('resource', 0);
const operation = this.getNodeParameter('operation', 0);
for (let i = 0; i < items.length; i++) {
try {
let responseData;
// ----------------------------------------
// account
// ----------------------------------------
if (resource === 'account') {
if (operation === 'getProfile') {
const accountId = this.getNodeParameter('accountId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/accounts/${accountId}/profile`);
}
else if (operation === 'getProfileByHandle') {
const handle = this.getNodeParameter('handle', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/accounts/handle/${handle}/profile`);
}
else if (operation === 'getLimits') {
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/accounts/limits');
}
}
// ----------------------------------------
// balance
// ----------------------------------------
if (resource === 'balance') {
if (operation === 'get') {
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/balances');
}
}
// ----------------------------------------
// currencyExchange
// ----------------------------------------
if (resource === 'currencyExchange') {
if (operation === 'createQuote') {
const sell = this.getNodeParameter('sell', i);
const buy = this.getNodeParameter('buy', i);
const amount = this.getNodeParameter('amount', i);
const amountCurrency = this.getNodeParameter('amountCurrency', i);
const body = {
sell,
buy,
amount: {
amount: amount.toString(),
currency: amountCurrency === 'sell' ? sell : buy,
},
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/currency-exchange-quotes', body);
}
else if (operation === 'getQuote') {
const quoteId = this.getNodeParameter('quoteId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/currency-exchange-quotes/${quoteId}`);
}
else if (operation === 'executeQuote') {
const quoteId = this.getNodeParameter('quoteId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'PATCH', `/currency-exchange-quotes/${quoteId}/execute`);
}
}
// ----------------------------------------
// deposit
// ----------------------------------------
if (resource === 'deposit') {
if (operation === 'create') {
const paymentMethodId = this.getNodeParameter('paymentMethodId', i);
const amount = this.getNodeParameter('amount', i);
const currency = this.getNodeParameter('currency', i);
const body = {
paymentMethodId,
amount: {
amount: amount.toString(),
currency,
},
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/deposits', body);
}
else if (operation === 'get') {
const depositId = this.getNodeParameter('depositId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/deposits/${depositId}`);
}
else if (operation === 'getAll') {
const returnAll = this.getNodeParameter('returnAll', i);
const filters = this.getNodeParameter('filters', i);
const query = {};
if (filters.filter) {
query.$filter = filters.filter;
}
if (filters.orderBy) {
query.$orderby = filters.orderBy;
}
if (returnAll) {
responseData = await StrikeApi_1.strikeApiRequestAllItems.call(this, 'GET', '/deposits', {}, query);
}
else {
const limit = this.getNodeParameter('limit', i);
query.$top = limit;
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/deposits', {}, query);
responseData = responseData.items || responseData;
}
}
else if (operation === 'estimateFee') {
const amount = this.getNodeParameter('amount', i);
const currency = this.getNodeParameter('currency', i);
const feePolicy = this.getNodeParameter('feePolicy', i);
const body = {
amount: {
amount: amount.toString(),
currency,
},
feePolicy,
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/deposits/fee', body);
}
}
// ----------------------------------------
// invoice
// ----------------------------------------
if (resource === 'invoice') {
if (operation === 'create') {
const correlationId = this.getNodeParameter('correlationId', i);
const description = this.getNodeParameter('description', i);
const amount = this.getNodeParameter('amount', i);
const currency = this.getNodeParameter('currency', i);
const body = {};
if (correlationId) {
body.correlationId = correlationId;
}
if (description) {
body.description = description;
}
if (amount > 0) {
body.amount = {
amount: amount.toString(),
currency,
};
}
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/invoices', body);
}
else if (operation === 'get') {
const invoiceId = this.getNodeParameter('invoiceId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/invoices/${invoiceId}`);
}
else if (operation === 'getAll') {
const returnAll = this.getNodeParameter('returnAll', i);
const filters = this.getNodeParameter('filters', i);
const query = {};
if (filters.filter) {
query.$filter = filters.filter;
}
if (filters.orderBy) {
query.$orderby = filters.orderBy;
}
if (returnAll) {
responseData = await StrikeApi_1.strikeApiRequestAllItems.call(this, 'GET', '/invoices', {}, query);
}
else {
const limit = this.getNodeParameter('limit', i);
query.$top = limit;
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/invoices', {}, query);
responseData = responseData.items || responseData;
}
}
else if (operation === 'createQuote') {
const invoiceId = this.getNodeParameter('invoiceId', i);
const descriptionHash = this.getNodeParameter('descriptionHash', i);
const body = {};
if (descriptionHash) {
body.descriptionHash = descriptionHash;
}
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', `/invoices/${invoiceId}/quote`, body);
}
else if (operation === 'cancel') {
const invoiceId = this.getNodeParameter('invoiceId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'PATCH', `/invoices/${invoiceId}/cancel`);
}
}
// ----------------------------------------
// payment
// ----------------------------------------
if (resource === 'payment') {
if (operation === 'get') {
const paymentId = this.getNodeParameter('paymentId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/payments/${paymentId}`);
}
else if (operation === 'createLightningQuote') {
const lnInvoice = this.getNodeParameter('lnInvoice', i);
const sourceCurrency = this.getNodeParameter('sourceCurrency', i);
const body = {
lnInvoice,
sourceCurrency,
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/payment-quotes/lightning', body);
}
else if (operation === 'createOnchainQuote') {
const btcAddress = this.getNodeParameter('btcAddress', i);
const sourceCurrency = this.getNodeParameter('sourceCurrency', i);
const amount = this.getNodeParameter('amount', i);
const amountCurrency = this.getNodeParameter('amountCurrency', i);
const body = {
btcAddress,
sourceCurrency,
amount: {
amount: amount.toString(),
currency: amountCurrency,
},
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/payment-quotes/onchain', body);
}
else if (operation === 'createLnurlQuote') {
const lnAddressOrUrl = this.getNodeParameter('lnAddressOrUrl', i);
const amount = this.getNodeParameter('amount', i);
const amountCurrency = this.getNodeParameter('amountCurrency', i);
const sourceCurrency = this.getNodeParameter('sourceCurrency', i);
const body = {
lnAddressOrUrl,
sourceCurrency,
amount: {
amount: amount.toString(),
currency: amountCurrency,
},
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/payment-quotes/lightning/lnurl', body);
}
else if (operation === 'getLnurlDetails') {
const lnAddressOrUrl = this.getNodeParameter('lnAddressOrUrl', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/payment-quotes/lightning/lnurl/${encodeURIComponent(lnAddressOrUrl)}`);
}
else if (operation === 'executeQuote') {
const paymentQuoteId = this.getNodeParameter('paymentQuoteId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'PATCH', `/payment-quotes/${paymentQuoteId}/execute`);
}
}
// ----------------------------------------
// paymentMethod
// ----------------------------------------
if (resource === 'paymentMethod') {
if (operation === 'createBank') {
const accountNumber = this.getNodeParameter('accountNumber', i);
const routingNumber = this.getNodeParameter('routingNumber', i);
const accountType = this.getNodeParameter('accountType', i);
const body = {
accountNumber,
routingNumber,
accountType,
};
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/payment-methods/bank', body);
}
else if (operation === 'get') {
const paymentMethodId = this.getNodeParameter('paymentMethodId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/payment-methods/bank/${paymentMethodId}`);
}
else if (operation === 'getAll') {
const returnAll = this.getNodeParameter('returnAll', i);
const options = this.getNodeParameter('options', i);
const query = {};
if (options.depositEligible) {
query.depositEligible = true;
}
if (returnAll) {
responseData = await StrikeApi_1.strikeApiRequestAllItems.call(this, 'GET', '/payment-methods/bank', {}, query);
}
else {
const limit = this.getNodeParameter('limit', i);
query.$top = limit;
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/payment-methods/bank', {}, query);
responseData = responseData.items || responseData;
}
}
else if (operation === 'delete') {
const paymentMethodId = this.getNodeParameter('paymentMethodId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'DELETE', `/payment-methods/bank/${paymentMethodId}`);
responseData = { success: true };
}
}
// ----------------------------------------
// payout
// ----------------------------------------
if (resource === 'payout') {
if (operation === 'create') {
const paymentMethodId = this.getNodeParameter('paymentMethodId', i);
const amount = this.getNodeParameter('amount', i);
const currency = this.getNodeParameter('currency', i);
const additionalFields = this.getNodeParameter('additionalFields', i);
const body = {
paymentMethodId,
amount: {
amount: amount.toString(),
currency,
},
};
if (additionalFields.feePolicy) {
body.feePolicy = additionalFields.feePolicy;
}
if (additionalFields.originatorId) {
body.originatorId = additionalFields.originatorId;
}
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'POST', '/payouts', body);
}
else if (operation === 'get') {
const payoutId = this.getNodeParameter('payoutId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/payouts/${payoutId}`);
}
else if (operation === 'getAll') {
const returnAll = this.getNodeParameter('returnAll', i);
const filters = this.getNodeParameter('filters', i);
const query = {};
if (filters.filter) {
query.$filter = filters.filter;
}
if (filters.orderBy) {
query.$orderby = filters.orderBy;
}
if (returnAll) {
responseData = await StrikeApi_1.strikeApiRequestAllItems.call(this, 'GET', '/payouts', {}, query);
}
else {
const limit = this.getNodeParameter('limit', i);
query.$top = limit;
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', '/payouts', {}, query);
responseData = responseData.items || responseData;
}
}
else if (operation === 'initiate') {
const payoutId = this.getNodeParameter('payoutId', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'PATCH', `/payouts/${payoutId}/initiate`);
}
}
// ----------------------------------------
// rates
// ----------------------------------------
if (resource === 'rates') {
if (operation === 'getTicker') {
const currencyPair = this.getNodeParameter('currencyPair', i);
responseData = await StrikeApi_1.strikeApiRequest.call(this, 'GET', `/rates/ticker/${currencyPair}`);
}
}
// Return data
const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
returnData.push(...executionData);
}
catch (error) {
if (this.continueOnFail()) {
const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
returnData.push(...executionData);
continue;
}
throw error;
}
}
return [returnData];
}
}
exports.Strike = Strike;

4
dist/nodes/Strike/StrikeApi.d.ts vendored Normal file
View File

@ -0,0 +1,4 @@
import type { IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
import type { IDataObject, IHttpRequestMethods } from 'n8n-workflow';
export declare function strikeApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, query?: IDataObject): Promise<any>;
export declare function strikeApiRequestAllItems(this: IExecuteFunctions | ILoadOptionsFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, query?: IDataObject): Promise<any[]>;

42
dist/nodes/Strike/StrikeApi.js vendored Normal file
View File

@ -0,0 +1,42 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.strikeApiRequest = strikeApiRequest;
exports.strikeApiRequestAllItems = strikeApiRequestAllItems;
async function strikeApiRequest(method, endpoint, body = {}, query = {}) {
const credentials = await this.getCredentials('strikeApi');
const baseUrl = credentials.environment === 'sandbox'
? 'https://api.strike.me'
: 'https://api.strike.me';
const options = {
method,
url: `${baseUrl}/v1${endpoint}`,
headers: {
'Content-Type': 'application/json',
},
body,
qs: query,
json: true,
};
if (Object.keys(body).length === 0) {
delete options.body;
}
if (Object.keys(query).length === 0) {
delete options.qs;
}
return this.helpers.requestWithAuthentication.call(this, 'strikeApi', options);
}
async function strikeApiRequestAllItems(method, endpoint, body = {}, query = {}) {
const returnData = [];
let responseData;
query.$top = query.$top || 100;
query.$skip = 0;
do {
responseData = await strikeApiRequest.call(this, method, endpoint, body, query);
const items = responseData.items || responseData;
if (Array.isArray(items)) {
returnData.push(...items);
}
query.$skip += query.$top;
} while (responseData.items && responseData.items.length === query.$top);
return returnData;
}

3
dist/nodes/Strike/descriptions/AccountDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const accountOperations: INodeProperties[];
export declare const accountFields: INodeProperties[];

73
dist/nodes/Strike/descriptions/AccountDescription.js vendored Normal file
View File

@ -0,0 +1,73 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.accountFields = exports.accountOperations = void 0;
exports.accountOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['account'],
},
},
options: [
{
name: 'Get Profile',
value: 'getProfile',
description: 'Get account profile by ID',
action: 'Get account profile',
},
{
name: 'Get Profile by Handle',
value: 'getProfileByHandle',
description: 'Get account profile by handle',
action: 'Get account profile by handle',
},
{
name: 'Get Limits',
value: 'getLimits',
description: 'Get account limits',
action: 'Get account limits',
},
],
default: 'getLimits',
},
];
exports.accountFields = [
// ----------------------------------
// account:getProfile
// ----------------------------------
{
displayName: 'Account ID',
name: 'accountId',
type: 'string',
required: true,
default: '',
description: 'The ID of the account',
displayOptions: {
show: {
resource: ['account'],
operation: ['getProfile'],
},
},
},
// ----------------------------------
// account:getProfileByHandle
// ----------------------------------
{
displayName: 'Handle',
name: 'handle',
type: 'string',
required: true,
default: '',
description: 'The handle of the account (username)',
displayOptions: {
show: {
resource: ['account'],
operation: ['getProfileByHandle'],
},
},
},
];

3
dist/nodes/Strike/descriptions/BalanceDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const balanceOperations: INodeProperties[];
export declare const balanceFields: INodeProperties[];

26
dist/nodes/Strike/descriptions/BalanceDescription.js vendored Normal file
View File

@ -0,0 +1,26 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.balanceFields = exports.balanceOperations = void 0;
exports.balanceOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['balance'],
},
},
options: [
{
name: 'Get',
value: 'get',
description: 'Get account balances',
action: 'Get account balances',
},
],
default: 'get',
},
];
exports.balanceFields = [];

3
dist/nodes/Strike/descriptions/CurrencyExchangeDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const currencyExchangeOperations: INodeProperties[];
export declare const currencyExchangeFields: INodeProperties[];

131
dist/nodes/Strike/descriptions/CurrencyExchangeDescription.js vendored Normal file
View File

@ -0,0 +1,131 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.currencyExchangeFields = exports.currencyExchangeOperations = void 0;
exports.currencyExchangeOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['currencyExchange'],
},
},
options: [
{
name: 'Create Quote',
value: 'createQuote',
description: 'Create a currency exchange quote',
action: 'Create a currency exchange quote',
},
{
name: 'Get Quote',
value: 'getQuote',
description: 'Get a currency exchange quote',
action: 'Get a currency exchange quote',
},
{
name: 'Execute Quote',
value: 'executeQuote',
description: 'Execute a currency exchange quote',
action: 'Execute a currency exchange quote',
},
],
default: 'createQuote',
},
];
exports.currencyExchangeFields = [
// ----------------------------------
// currencyExchange:createQuote
// ----------------------------------
{
displayName: 'Sell Currency',
name: 'sell',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency to sell',
displayOptions: {
show: {
resource: ['currencyExchange'],
operation: ['createQuote'],
},
},
},
{
displayName: 'Buy Currency',
name: 'buy',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'BTC',
description: 'Currency to buy',
displayOptions: {
show: {
resource: ['currencyExchange'],
operation: ['createQuote'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 8,
},
required: true,
default: 0,
description: 'Amount to exchange',
displayOptions: {
show: {
resource: ['currencyExchange'],
operation: ['createQuote'],
},
},
},
{
displayName: 'Amount Currency',
name: 'amountCurrency',
type: 'options',
options: [
{ name: 'Sell Currency', value: 'sell' },
{ name: 'Buy Currency', value: 'buy' },
],
default: 'sell',
description: 'Which currency the amount is specified in',
displayOptions: {
show: {
resource: ['currencyExchange'],
operation: ['createQuote'],
},
},
},
// ----------------------------------
// currencyExchange:getQuote & executeQuote
// ----------------------------------
{
displayName: 'Quote ID',
name: 'quoteId',
type: 'string',
required: true,
default: '',
description: 'The ID of the currency exchange quote',
displayOptions: {
show: {
resource: ['currencyExchange'],
operation: ['getQuote', 'executeQuote'],
},
},
},
];

3
dist/nodes/Strike/descriptions/DepositDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const depositOperations: INodeProperties[];
export declare const depositFields: INodeProperties[];

196
dist/nodes/Strike/descriptions/DepositDescription.js vendored Normal file
View File

@ -0,0 +1,196 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.depositFields = exports.depositOperations = void 0;
exports.depositOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['deposit'],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Initiate a deposit',
action: 'Create a deposit',
},
{
name: 'Get',
value: 'get',
description: 'Get a deposit by ID',
action: 'Get a deposit',
},
{
name: 'Get Many',
value: 'getAll',
description: 'Get many deposits',
action: 'Get many deposits',
},
{
name: 'Estimate Fee',
value: 'estimateFee',
description: 'Estimate deposit fees',
action: 'Estimate deposit fee',
},
],
default: 'getAll',
},
];
exports.depositFields = [
// ----------------------------------
// deposit:create
// ----------------------------------
{
displayName: 'Payment Method ID',
name: 'paymentMethodId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payment method to deposit from',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['create'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 2,
},
required: true,
default: 0,
description: 'Amount to deposit',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['create', 'estimateFee'],
},
},
},
{
displayName: 'Currency',
name: 'currency',
type: 'options',
options: [
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency of the deposit',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['create', 'estimateFee'],
},
},
},
// ----------------------------------
// deposit:get
// ----------------------------------
{
displayName: 'Deposit ID',
name: 'depositId',
type: 'string',
required: true,
default: '',
description: 'The ID of the deposit to retrieve',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['get'],
},
},
},
// ----------------------------------
// deposit:getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['getAll'],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
typeOptions: {
minValue: 1,
},
default: 50,
description: 'Max number of results to return',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['getAll'],
returnAll: [false],
},
},
},
{
displayName: 'Filters',
name: 'filters',
type: 'collection',
placeholder: 'Add Filter',
default: {},
displayOptions: {
show: {
resource: ['deposit'],
operation: ['getAll'],
},
},
options: [
{
displayName: 'Filter (OData)',
name: 'filter',
type: 'string',
default: '',
description: 'OData filter expression',
},
{
displayName: 'Order By',
name: 'orderBy',
type: 'string',
default: 'created desc',
description: 'OData orderby expression',
},
],
},
// ----------------------------------
// deposit:estimateFee
// ----------------------------------
{
displayName: 'Fee Policy',
name: 'feePolicy',
type: 'options',
options: [
{ name: 'Inclusive', value: 'INCLUSIVE' },
{ name: 'Exclusive', value: 'EXCLUSIVE' },
],
default: 'EXCLUSIVE',
description: 'Whether fee is included in or added to the amount',
displayOptions: {
show: {
resource: ['deposit'],
operation: ['estimateFee'],
},
},
},
];

3
dist/nodes/Strike/descriptions/InvoiceDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const invoiceOperations: INodeProperties[];
export declare const invoiceFields: INodeProperties[];

210
dist/nodes/Strike/descriptions/InvoiceDescription.js vendored Normal file
View File

@ -0,0 +1,210 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.invoiceFields = exports.invoiceOperations = void 0;
exports.invoiceOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['invoice'],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create an invoice',
action: 'Create an invoice',
},
{
name: 'Get',
value: 'get',
description: 'Get an invoice by ID',
action: 'Get an invoice',
},
{
name: 'Get Many',
value: 'getAll',
description: 'Get many invoices',
action: 'Get many invoices',
},
{
name: 'Create Quote',
value: 'createQuote',
description: 'Generate a quote for an invoice',
action: 'Create quote for an invoice',
},
{
name: 'Cancel',
value: 'cancel',
description: 'Cancel an unpaid invoice',
action: 'Cancel an invoice',
},
],
default: 'getAll',
},
];
exports.invoiceFields = [
// ----------------------------------
// invoice:create
// ----------------------------------
{
displayName: 'Correlation ID',
name: 'correlationId',
type: 'string',
default: '',
description: 'Unique identifier for idempotency',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['create'],
},
},
},
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
description: 'Description of the invoice',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['create'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 8,
},
default: 0,
description: 'Amount for the invoice (leave empty for any amount)',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['create'],
},
},
},
{
displayName: 'Currency',
name: 'currency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency for the invoice amount',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['create'],
},
},
},
// ----------------------------------
// invoice:get
// ----------------------------------
{
displayName: 'Invoice ID',
name: 'invoiceId',
type: 'string',
required: true,
default: '',
description: 'The ID of the invoice to retrieve',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['get', 'createQuote', 'cancel'],
},
},
},
// ----------------------------------
// invoice:getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['getAll'],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
typeOptions: {
minValue: 1,
},
default: 50,
description: 'Max number of results to return',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['getAll'],
returnAll: [false],
},
},
},
{
displayName: 'Filters',
name: 'filters',
type: 'collection',
placeholder: 'Add Filter',
default: {},
displayOptions: {
show: {
resource: ['invoice'],
operation: ['getAll'],
},
},
options: [
{
displayName: 'Filter (OData)',
name: 'filter',
type: 'string',
default: '',
description: 'OData filter expression (e.g., state eq \'UNPAID\')',
},
{
displayName: 'Order By',
name: 'orderBy',
type: 'string',
default: 'created desc',
description: 'OData orderby expression',
},
],
},
// ----------------------------------
// invoice:createQuote
// ----------------------------------
{
displayName: 'Description Hash',
name: 'descriptionHash',
type: 'string',
default: '',
description: 'Optional description hash for the quote',
displayOptions: {
show: {
resource: ['invoice'],
operation: ['createQuote'],
},
},
},
];

3
dist/nodes/Strike/descriptions/PaymentDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const paymentOperations: INodeProperties[];
export declare const paymentFields: INodeProperties[];

271
dist/nodes/Strike/descriptions/PaymentDescription.js vendored Normal file
View File

@ -0,0 +1,271 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.paymentFields = exports.paymentOperations = void 0;
exports.paymentOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['payment'],
},
},
options: [
{
name: 'Get',
value: 'get',
description: 'Get a payment by ID',
action: 'Get a payment',
},
{
name: 'Create Lightning Quote',
value: 'createLightningQuote',
description: 'Create a lightning payment quote',
action: 'Create a lightning payment quote',
},
{
name: 'Create On-Chain Quote',
value: 'createOnchainQuote',
description: 'Create an on-chain payment quote',
action: 'Create an on-chain payment quote',
},
{
name: 'Create LNURL Quote',
value: 'createLnurlQuote',
description: 'Create a payment quote for LN Address or LNURL',
action: 'Create an LNURL payment quote',
},
{
name: 'Get LNURL Details',
value: 'getLnurlDetails',
description: 'Get details for an LN Address or LNURL',
action: 'Get LNURL details',
},
{
name: 'Execute Quote',
value: 'executeQuote',
description: 'Execute a payment quote',
action: 'Execute a payment quote',
},
],
default: 'get',
},
];
exports.paymentFields = [
// ----------------------------------
// payment:get
// ----------------------------------
{
displayName: 'Payment ID',
name: 'paymentId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payment to retrieve',
displayOptions: {
show: {
resource: ['payment'],
operation: ['get'],
},
},
},
// ----------------------------------
// payment:createLightningQuote
// ----------------------------------
{
displayName: 'Lightning Invoice (BOLT11)',
name: 'lnInvoice',
type: 'string',
required: true,
default: '',
description: 'The BOLT11 lightning invoice to pay',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLightningQuote'],
},
},
},
{
displayName: 'Source Currency',
name: 'sourceCurrency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency to pay from',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLightningQuote'],
},
},
},
// ----------------------------------
// payment:createOnchainQuote
// ----------------------------------
{
displayName: 'Bitcoin Address',
name: 'btcAddress',
type: 'string',
required: true,
default: '',
description: 'The Bitcoin address to send to',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createOnchainQuote'],
},
},
},
{
displayName: 'Source Currency',
name: 'sourceCurrency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency to pay from',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createOnchainQuote'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 8,
},
required: true,
default: 0,
description: 'Amount to send',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createOnchainQuote'],
},
},
},
{
displayName: 'Amount Currency',
name: 'amountCurrency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'BTC',
description: 'Currency of the amount',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createOnchainQuote'],
},
},
},
// ----------------------------------
// payment:createLnurlQuote
// ----------------------------------
{
displayName: 'LN Address or LNURL',
name: 'lnAddressOrUrl',
type: 'string',
required: true,
default: '',
description: 'Lightning Address (user@domain.com) or LNURL',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLnurlQuote', 'getLnurlDetails'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 8,
},
required: true,
default: 0,
description: 'Amount to send',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLnurlQuote'],
},
},
},
{
displayName: 'Amount Currency',
name: 'amountCurrency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency of the amount',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLnurlQuote'],
},
},
},
{
displayName: 'Source Currency',
name: 'sourceCurrency',
type: 'options',
options: [
{ name: 'BTC', value: 'BTC' },
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency to pay from',
displayOptions: {
show: {
resource: ['payment'],
operation: ['createLnurlQuote'],
},
},
},
// ----------------------------------
// payment:executeQuote
// ----------------------------------
{
displayName: 'Payment Quote ID',
name: 'paymentQuoteId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payment quote to execute',
displayOptions: {
show: {
resource: ['payment'],
operation: ['executeQuote'],
},
},
},
];

3
dist/nodes/Strike/descriptions/PaymentMethodDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const paymentMethodOperations: INodeProperties[];
export declare const paymentMethodFields: INodeProperties[];

165
dist/nodes/Strike/descriptions/PaymentMethodDescription.js vendored Normal file
View File

@ -0,0 +1,165 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.paymentMethodFields = exports.paymentMethodOperations = void 0;
exports.paymentMethodOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['paymentMethod'],
},
},
options: [
{
name: 'Create Bank Account',
value: 'createBank',
description: 'Create a bank payment method',
action: 'Create a bank payment method',
},
{
name: 'Get',
value: 'get',
description: 'Get a bank payment method by ID',
action: 'Get a bank payment method',
},
{
name: 'Get Many',
value: 'getAll',
description: 'Get many bank payment methods',
action: 'Get many bank payment methods',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete a bank payment method',
action: 'Delete a bank payment method',
},
],
default: 'getAll',
},
];
exports.paymentMethodFields = [
// ----------------------------------
// paymentMethod:createBank
// ----------------------------------
{
displayName: 'Account Number',
name: 'accountNumber',
type: 'string',
required: true,
default: '',
description: 'Bank account number',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['createBank'],
},
},
},
{
displayName: 'Routing Number',
name: 'routingNumber',
type: 'string',
required: true,
default: '',
description: 'Bank routing number',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['createBank'],
},
},
},
{
displayName: 'Account Type',
name: 'accountType',
type: 'options',
options: [
{ name: 'Checking', value: 'CHECKING' },
{ name: 'Savings', value: 'SAVINGS' },
],
default: 'CHECKING',
description: 'Type of bank account',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['createBank'],
},
},
},
// ----------------------------------
// paymentMethod:get & delete
// ----------------------------------
{
displayName: 'Payment Method ID',
name: 'paymentMethodId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payment method',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['get', 'delete'],
},
},
},
// ----------------------------------
// paymentMethod:getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['getAll'],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
typeOptions: {
minValue: 1,
},
default: 50,
description: 'Max number of results to return',
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['getAll'],
returnAll: [false],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource: ['paymentMethod'],
operation: ['getAll'],
},
},
options: [
{
displayName: 'Deposit Eligible Only',
name: 'depositEligible',
type: 'boolean',
default: false,
description: 'Whether to only return deposit-eligible payment methods',
},
],
},
];

3
dist/nodes/Strike/descriptions/PayoutDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const payoutOperations: INodeProperties[];
export declare const payoutFields: INodeProperties[];

209
dist/nodes/Strike/descriptions/PayoutDescription.js vendored Normal file
View File

@ -0,0 +1,209 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.payoutFields = exports.payoutOperations = void 0;
exports.payoutOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['payout'],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a payout',
action: 'Create a payout',
},
{
name: 'Get',
value: 'get',
description: 'Get a payout by ID',
action: 'Get a payout',
},
{
name: 'Get Many',
value: 'getAll',
description: 'Get many payouts',
action: 'Get many payouts',
},
{
name: 'Initiate',
value: 'initiate',
description: 'Initiate a payout',
action: 'Initiate a payout',
},
],
default: 'getAll',
},
];
exports.payoutFields = [
// ----------------------------------
// payout:create
// ----------------------------------
{
displayName: 'Payment Method ID',
name: 'paymentMethodId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payment method to payout to',
displayOptions: {
show: {
resource: ['payout'],
operation: ['create'],
},
},
},
{
displayName: 'Amount',
name: 'amount',
type: 'number',
typeOptions: {
numberPrecision: 2,
},
required: true,
default: 0,
description: 'Amount to payout',
displayOptions: {
show: {
resource: ['payout'],
operation: ['create'],
},
},
},
{
displayName: 'Currency',
name: 'currency',
type: 'options',
options: [
{ name: 'USD', value: 'USD' },
{ name: 'EUR', value: 'EUR' },
{ name: 'GBP', value: 'GBP' },
],
default: 'USD',
description: 'Currency of the payout',
displayOptions: {
show: {
resource: ['payout'],
operation: ['create'],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: ['payout'],
operation: ['create'],
},
},
options: [
{
displayName: 'Fee Policy',
name: 'feePolicy',
type: 'options',
options: [
{ name: 'Inclusive', value: 'INCLUSIVE' },
{ name: 'Exclusive', value: 'EXCLUSIVE' },
],
default: 'EXCLUSIVE',
description: 'Whether fee is included in or added to the amount',
},
{
displayName: 'Originator ID',
name: 'originatorId',
type: 'string',
default: '',
description: 'ID of the payout originator',
},
],
},
// ----------------------------------
// payout:get
// ----------------------------------
{
displayName: 'Payout ID',
name: 'payoutId',
type: 'string',
required: true,
default: '',
description: 'The ID of the payout to retrieve',
displayOptions: {
show: {
resource: ['payout'],
operation: ['get', 'initiate'],
},
},
},
// ----------------------------------
// payout:getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: ['payout'],
operation: ['getAll'],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
typeOptions: {
minValue: 1,
},
default: 50,
description: 'Max number of results to return',
displayOptions: {
show: {
resource: ['payout'],
operation: ['getAll'],
returnAll: [false],
},
},
},
{
displayName: 'Filters',
name: 'filters',
type: 'collection',
placeholder: 'Add Filter',
default: {},
displayOptions: {
show: {
resource: ['payout'],
operation: ['getAll'],
},
},
options: [
{
displayName: 'Filter (OData)',
name: 'filter',
type: 'string',
default: '',
description: 'OData filter expression',
},
{
displayName: 'Order By',
name: 'orderBy',
type: 'string',
default: 'created desc',
description: 'OData orderby expression',
},
],
},
];

3
dist/nodes/Strike/descriptions/RatesDescription.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
import type { INodeProperties } from 'n8n-workflow';
export declare const ratesOperations: INodeProperties[];
export declare const ratesFields: INodeProperties[];

48
dist/nodes/Strike/descriptions/RatesDescription.js vendored Normal file
View File

@ -0,0 +1,48 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ratesFields = exports.ratesOperations = void 0;
exports.ratesOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['rates'],
},
},
options: [
{
name: 'Get Ticker',
value: 'getTicker',
description: 'Get current exchange rates',
action: 'Get exchange rates',
},
],
default: 'getTicker',
},
];
exports.ratesFields = [
// ----------------------------------
// rates:getTicker
// ----------------------------------
{
displayName: 'Currency Pair',
name: 'currencyPair',
type: 'options',
options: [
{ name: 'BTC/USD', value: 'BTCUSD' },
{ name: 'BTC/EUR', value: 'BTCEUR' },
{ name: 'BTC/GBP', value: 'BTCGBP' },
],
default: 'BTCUSD',
description: 'Currency pair for the ticker',
displayOptions: {
show: {
resource: ['rates'],
operation: ['getTicker'],
},
},
},
];

9
dist/nodes/Strike/descriptions/index.d.ts vendored Normal file
View File

@ -0,0 +1,9 @@
export * from './BalanceDescription';
export * from './InvoiceDescription';
export * from './PaymentDescription';
export * from './DepositDescription';
export * from './PayoutDescription';
export * from './CurrencyExchangeDescription';
export * from './RatesDescription';
export * from './AccountDescription';
export * from './PaymentMethodDescription';

25
dist/nodes/Strike/descriptions/index.js vendored Normal file
View File

@ -0,0 +1,25 @@
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require("./BalanceDescription"), exports);
__exportStar(require("./InvoiceDescription"), exports);
__exportStar(require("./PaymentDescription"), exports);
__exportStar(require("./DepositDescription"), exports);
__exportStar(require("./PayoutDescription"), exports);
__exportStar(require("./CurrencyExchangeDescription"), exports);
__exportStar(require("./RatesDescription"), exports);
__exportStar(require("./AccountDescription"), exports);
__exportStar(require("./PaymentMethodDescription"), exports);

4
dist/nodes/Strike/strike.svg vendored Normal file
View File

@ -0,0 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" fill="none">
<rect width="32" height="32" rx="4" fill="#000000"/>
<path d="M22 10H14L12 16H18L10 22L20 14H14L16 10H22Z" fill="#CCFF00"/>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 208 B