@powerhousedao/contributor-billing 0.0.1

package/dist/editors/invoice/utils/utils.js

@@ -0,0 +1,54 @@
+import countries from "world-countries";
+const countriesArray = countries;
+// Function to convert country name to country code
+export const getCountryCodeFromName = (countryName) => {
+    if (!countryName)
+        return "";
+    // Special case handling for common abbreviations and alternative names
+    const specialCases = {
+        uk: "GB",
+        "united kingdom": "GB",
+        england: "GB",
+        britain: "GB",
+        deutschland: "DE",
+        germany: "DE",
+        usa: "US",
+        "united states of america": "US",
+        america: "US",
+    };
+    const lowerCountryName = countryName.toLowerCase().trim();
+    // Check special cases first
+    if (specialCases[lowerCountryName]) {
+        return specialCases[lowerCountryName];
+    }
+    // Check if input is already a valid country code (2-letter code)
+    if (countryName.length === 2 && /^[A-Z]{2}$/.test(countryName)) {
+        const isValidCode = countriesArray.some((c) => c.cca2 === countryName);
+        if (isValidCode)
+            return countryName;
+    }
+    // Try exact match first (case-insensitive)
+    const exactMatch = countriesArray.find((c) => c.name.common.toLowerCase() === lowerCountryName);
+    if (exactMatch)
+        return exactMatch.cca2;
+    // Try official name match
+    const officialMatch = countriesArray.find((c) => c.name.official.toLowerCase() === lowerCountryName);
+    if (officialMatch)
+        return officialMatch.cca2;
+    // Try native name matches
+    const nativeMatch = countriesArray.find((c) => {
+        if (!c.name.native)
+            return false;
+        return Object.values(c.name.native).some((n) => n.common.toLowerCase() === lowerCountryName ||
+            n.official.toLowerCase() === lowerCountryName);
+    });
+    if (nativeMatch)
+        return nativeMatch.cca2;
+    // Try partial match if no exact match found
+    const partialMatch = countriesArray.find((c) => c.name.common.toLowerCase().includes(lowerCountryName) ||
+        lowerCountryName.includes(c.name.common.toLowerCase()));
+    if (partialMatch)
+        return partialMatch.cca2;
+    // If no match found, return original value
+    return countryName;
+};

package/dist/editors/invoice/validation/validationManager.d.ts

@@ -0,0 +1,28 @@
+import { Status } from "../../../document-models/invoice/index.js";
+export type ValidationSeverity = 'error' | 'warning' | 'none';
+export type ValidationResult = {
+    isValid: boolean;
+    message: string;
+    severity: ValidationSeverity;
+};
+export type ValidationRule = {
+    field: string;
+    validate: (value: any, context?: any) => ValidationResult;
+    appliesTo: {
+        currencies: Array<string | 'ALL'>;
+        statusTransitions: {
+            from: Status[];
+            to: Status[];
+        };
+    };
+};
+export type ValidationContext = {
+    currency: string;
+    currentStatus: Status;
+    targetStatus: Status;
+};
+export declare function validateField(field: string, value: any, context: ValidationContext): ValidationResult | null;
+export declare function validateStatusTransition(fields: Record<string, any>, context: ValidationContext): Record<string, ValidationResult>;
+export declare function addValidationRule(rule: ValidationRule): void;
+export declare function removeValidationRule(field: string): void;
+//# sourceMappingURL=validationManager.d.ts.map

package/dist/editors/invoice/validation/validationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationManager.d.ts","sourceRoot":"","sources":["../../../../editors/invoice/validation/validationManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAInE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,kBAAkB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,gBAAgB,CAAC;IAC1D,SAAS,EAAE;QACP,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;QAClC,iBAAiB,EAAE;YACf,IAAI,EAAE,MAAM,EAAE,CAAC;YACf,EAAE,EAAE,MAAM,EAAE,CAAC;SAChB,CAAC;KACL,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AA8BF,wBAAgB,aAAa,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,iBAAiB,GAC3B,gBAAgB,GAAG,IAAI,CAqBzB;AAGD,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,OAAO,EAAE,iBAAiB,GAC3B,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAalC;AAGD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAE5D;AAGD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAKxD"}

package/dist/editors/invoice/validation/validationManager.js

@@ -0,0 +1,65 @@
+import { accountNumberRule, bicNumberRule, bankNameRule, countryRule, currencyRule, ethereumAddressRule, invoiceNumberRule, issuerPostalCodeRule, issuerStreetAddressRule, issuerCityRule, payerEmailRule, lineItemRule } from "./validationRules.js";
+// Validation rules registry
+const validationRules = [];
+// Register rules
+validationRules.push(invoiceNumberRule);
+validationRules.push(ethereumAddressRule);
+validationRules.push(currencyRule);
+validationRules.push(countryRule);
+validationRules.push(accountNumberRule);
+validationRules.push(bicNumberRule);
+validationRules.push(bankNameRule);
+validationRules.push(issuerStreetAddressRule);
+validationRules.push(issuerCityRule);
+validationRules.push(issuerPostalCodeRule);
+validationRules.push(payerEmailRule);
+validationRules.push(lineItemRule);
+// Helper to check if a rule applies to the current context
+function ruleAppliesToContext(rule, context) {
+    const { currencies, statusTransitions } = rule.appliesTo;
+    const currencyMatches = currencies.includes('ALL') || currencies.includes(context.currency);
+    const statusMatches = statusTransitions.from.includes(context.currentStatus) &&
+        statusTransitions.to.includes(context.targetStatus);
+    return currencyMatches && statusMatches;
+}
+// Main validation function
+export function validateField(field, value, context) {
+    const applicableRules = validationRules.filter(rule => rule.field === field && ruleAppliesToContext(rule, context));
+    if (applicableRules.length === 0) {
+        return null;
+    }
+    // Run all applicable rules and return the first failure or the last success
+    let lastResult = null;
+    for (const rule of applicableRules) {
+        const result = rule.validate(value);
+        if (!result.isValid) {
+            return result; // Return first failure
+        }
+        lastResult = result;
+    }
+    return lastResult;
+}
+// Validate all fields for a status transition
+export function validateStatusTransition(fields, context) {
+    const results = {};
+    validationRules.forEach(rule => {
+        if (ruleAppliesToContext(rule, context)) {
+            const result = rule.validate(fields[rule.field]);
+            if (!result.isValid) {
+                results[rule.field] = result;
+            }
+        }
+    });
+    return results;
+}
+// Add a new validation rule
+export function addValidationRule(rule) {
+    validationRules.push(rule);
+}
+// Remove a validation rule
+export function removeValidationRule(field) {
+    const index = validationRules.findIndex(rule => rule.field === field);
+    if (index !== -1) {
+        validationRules.splice(index, 1);
+    }
+}

package/dist/editors/invoice/validation/validationRules.d.ts

@@ -0,0 +1,14 @@
+import { ValidationRule } from "./validationManager.js";
+export declare const invoiceNumberRule: ValidationRule;
+export declare const ethereumAddressRule: ValidationRule;
+export declare const currencyRule: ValidationRule;
+export declare const countryRule: ValidationRule;
+export declare const accountNumberRule: ValidationRule;
+export declare const bicNumberRule: ValidationRule;
+export declare const bankNameRule: ValidationRule;
+export declare const issuerStreetAddressRule: ValidationRule;
+export declare const issuerCityRule: ValidationRule;
+export declare const issuerPostalCodeRule: ValidationRule;
+export declare const payerEmailRule: ValidationRule;
+export declare const lineItemRule: ValidationRule;
+//# sourceMappingURL=validationRules.d.ts.map

package/dist/editors/invoice/validation/validationRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationRules.d.ts","sourceRoot":"","sources":["../../../../editors/invoice/validation/validationRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAmBxD,eAAO,MAAM,iBAAiB,EAAE,cAuB/B,CAAC;AAGF,eAAO,MAAM,mBAAmB,EAAE,cA8BjC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,cAuB1B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,cAuBzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,cA8B/B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,cAkC3B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,cAuB1B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,cAuBrC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAuB5B,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,cAuBlC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cA8B5B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,cAuB1B,CAAC"}

package/dist/editors/invoice/validation/validationRules.js

@@ -0,0 +1,334 @@
+// Helper function to validate Ethereum address
+function isValidEthereumAddress(address) {
+    const ethereumAddressRegex = /^0x[a-fA-F0-9]{40}$/;
+    return ethereumAddressRegex.test(address);
+}
+function isValidIBAN(iban) {
+    const ibanRegex = /^([A-Z]{2}[0-9]{2})(?=(?:[A-Z0-9]){9,30}$)((?:[A-Z0-9]{3,5}){2,7})([A-Z0-9]{1,3})?$/;
+    return ibanRegex.test(iban);
+}
+function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+// Invoice number validation rule
+export const invoiceNumberRule = {
+    field: 'invoiceNo',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Invoice number is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['ALL'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+// Ethereum address validation rule
+export const ethereumAddressRule = {
+    field: 'address',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Wallet address is required',
+                severity: 'error'
+            };
+        }
+        if (!isValidEthereumAddress(value)) {
+            return {
+                isValid: false,
+                message: 'Invalid Ethereum address format',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USDS', 'DAI'], // Only apply for crypto currencies
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const currencyRule = {
+    field: 'currency',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Currency is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['ALL'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const countryRule = {
+    field: 'country',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Country is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const accountNumberRule = {
+    field: 'accountNum',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Account number is required',
+                severity: 'warning'
+            };
+        }
+        if (!isValidIBAN(value)) {
+            return {
+                isValid: false,
+                message: 'Invalid IBAN format - Remove spaces and/or dashes',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['EUR', 'GBP'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const bicNumberRule = {
+    field: 'bicNumber',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'BIC number is required',
+                severity: 'warning'
+            };
+        }
+        if (value) {
+            const bicRegex = /^[a-zA-Z]{6}[a-zA-Z0-9]{2}([a-zA-Z0-9]{3})?$/i;
+            if (!bicRegex.test(value)) {
+                return {
+                    isValid: false,
+                    message: 'Invalid BIC number format',
+                    severity: 'warning'
+                };
+            }
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['EUR', 'GBP'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const bankNameRule = {
+    field: 'bankName',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Bank name is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const issuerStreetAddressRule = {
+    field: 'streetAddress',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Street address is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const issuerCityRule = {
+    field: 'city',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'City is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const issuerPostalCodeRule = {
+    field: 'postalCode',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Postal code is required',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const payerEmailRule = {
+    field: 'email',
+    validate: (value) => {
+        if (!value || value.trim() === '') {
+            return {
+                isValid: false,
+                message: 'Email is required',
+                severity: 'warning'
+            };
+        }
+        if (!isValidEmail(value)) {
+            return {
+                isValid: false,
+                message: 'Invalid email format',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};
+export const lineItemRule = {
+    field: 'lineItem',
+    validate: (value) => {
+        if (value.length === 0) {
+            return {
+                isValid: false,
+                message: 'Line item is required - Add at least one line item',
+                severity: 'warning'
+            };
+        }
+        return {
+            isValid: true,
+            message: '',
+            severity: 'none'
+        };
+    },
+    appliesTo: {
+        currencies: ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CHF'],
+        statusTransitions: {
+            from: ['DRAFT'],
+            to: ['ISSUED']
+        }
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Manifest } from "document-model";
+export declare const manifest: Manifest;
+export declare const documentModels: import("document-model").DocumentModelModule<import("./document-models/invoice/index.js").InvoiceDocument>[];
+export declare const editors: (import("document-model").EditorModule<import("./document-models/invoice/index.js").InvoiceDocument> | import("@powerhousedao/reactor-browser").DriveEditorModule<import("document-drive").DocumentDriveDocument>)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK1C,eAAO,MAAM,QAAQ,EAAE,QAAuB,CAAC;AAC/C,eAAO,MAAM,cAAc,8GAAuC,CAAC;AACnE,eAAO,MAAM,OAAO,sNAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import manifestJson from "./powerhouse.manifest.json" with { type: "json" };
+import * as documentModelsExports from './document-models/index.js';
+import * as editorsExports from './editors/index.js';
+export const manifest = manifestJson;
+export const documentModels = Object.values(documentModelsExports);
+export const editors = Object.values(editorsExports);

package/dist/powerhouse.manifest.json

@@ -0,0 +1,31 @@
+{
+    "name": "Contributor Billing",
+    "description": "The invoice package offers contributors of decentralized and open organisations a way to get paid via their legal entity or governmental identity. ",
+    "category": "Workforce",
+    "publisher": {
+        "name": "Powerhouse",
+        "url": "https://www.powerhouse.inc/"
+    },
+    "documentModels": [
+        {
+            "id": "powerhouse/invoice",
+            "name": "Invoice"
+        }
+    ],
+    "editors": [
+        {
+            "id": "powerhouse/invoice-editor",
+            "name": "Invoice",
+            "documentTypes": ["powerhouse/invoice"]
+        }
+    ],
+    "apps": [
+        {
+            "id": "contributor-billing",
+            "name": "Contributor Billing",
+            "driveEditor": "contributor-billing"
+        }
+    ],
+    "subgraphs": [],
+    "importScripts": []
+}

package/dist/processors/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/processors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../processors/index.ts"],"names":[],"mappings":""}

package/dist/processors/index.js

@@ -0,0 +1 @@
+export {};

package/dist/scripts/invoice/exampleBatchTxn.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=exampleBatchTxn.d.ts.map

package/dist/scripts/invoice/exampleBatchTxn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exampleBatchTxn.d.ts","sourceRoot":"","sources":["../../../scripts/invoice/exampleBatchTxn.ts"],"names":[],"mappings":""}

package/dist/scripts/invoice/exampleBatchTxn.js

@@ -0,0 +1,44 @@
+import { executeTransferProposal } from './gnosisTransactionBuilder.js';
+import dotenv from 'dotenv';
+dotenv.config();
+async function testBatchTransfer() {
+    try {
+        const payerWallet = {
+            rpc: 'https://mainnet.base.org', // Base mainnet RPC
+            chainName: 'Base',
+            chainId: '8453',
+            address: '0x1FB6bEF04230d67aF0e3455B997a28AFcCe1F45e',
+        };
+        const paymentDetails = [
+            {
+                payeeWallet: {
+                    address: '0x48f208afD0Abeacd4e7C8839Ea19e3CcCF0433DE',
+                },
+                token: {
+                    symbol: 'USDS',
+                    evmAddress: '0x820C137fa70C8691f0e44Dc420a5e53c168921Dc',
+                    decimals: 6,
+                },
+                amount: '10',
+            },
+            {
+                payeeWallet: {
+                    address: '0x48f208afD0Abeacd4e7C8839Ea19e3CcCF0433DE',
+                },
+                token: {
+                    symbol: 'USDS',
+                    evmAddress: '0x820C137fa70C8691f0e44Dc420a5e53c168921Dc',
+                    decimals: 6,
+                },
+                amount: '15.5',
+            },
+        ];
+        const result = await executeTransferProposal(payerWallet, paymentDetails);
+        console.log('\n✅ Batch transaction proposed successfully:');
+        console.log(result);
+    }
+    catch (err) {
+        console.error('\n❌ Batch transaction test failed:', err);
+    }
+}
+testBatchTransfer();

package/dist/scripts/invoice/gnosisTransactionBuilder.d.ts

@@ -0,0 +1,28 @@
+export interface PayerWallet {
+    rpc: string;
+    chainName: string;
+    chainId: string;
+    address: string;
+}
+export interface PayeeWallet {
+    address: string;
+}
+export interface TokenInfo {
+    symbol: string;
+    evmAddress: string;
+    decimals: number;
+}
+export interface PaymentDetail {
+    payeeWallet: PayeeWallet;
+    token: TokenInfo;
+    amount: string | number;
+}
+export interface TransferResult {
+    success: true;
+    txHash: string;
+    safeAddress: string;
+    paymentDetails: PaymentDetail[];
+}
+declare function executeTransferProposal(payerWallet: PayerWallet, paymentDetailsInput: PaymentDetail | PaymentDetail[]): Promise<TransferResult>;
+export { executeTransferProposal };
+//# sourceMappingURL=gnosisTransactionBuilder.d.ts.map

package/dist/scripts/invoice/gnosisTransactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gnosisTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../scripts/invoice/gnosisTransactionBuilder.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,WAAW,CAAC;IACzB,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,aAAa,EAAE,CAAC;CACjC;AAGD,iBAAe,uBAAuB,CACpC,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,aAAa,GAAG,aAAa,EAAE,GACnD,OAAO,CAAC,cAAc,CAAC,CAkFzB;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}