@keetanetwork/anchor 0.0.23 → 0.0.24

package/services/asset-movement/client.js

@@ -1,7 +1,13 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
 import { getDefaultResolver } from '../../config.js';
-import { assertKeetaSupportedAssets, convertAssetLocationToString, convertAssetSearchInputToCanonical, isKeetaAssetMovementAnchorCreatePersistentForwardingResponse, isKeetaAssetMovementAnchorGetExchangeStatusResponse, isKeetaAssetMovementAnchorInitiateTransferResponse, isKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse } from './common.js';
+import { assertKeetaSupportedAssets, convertAssetLocationToString, convertAssetOrPairSearchInputToCanonical, convertAssetSearchInputToCanonical, getKeetaAssetMovementAnchorCreatePersistentForwardingAddressTemplateRequestSigningData, getKeetaAssetMovementAnchorCreatePersistentForwardingRequestSigningData, getKeetaAssetMovementAnchorGetTransferStatusRequestSigningData, getKeetaAssetMovementAnchorInitiateTransferRequestSigningData, getKeetaAssetMovementAnchorListForwardingAddressTemplateRequestSigningData, getKeetaAssetMovementAnchorlistTransactionsRequestSigningData, getKeetaAssetMovementAnchorShareKYCRequestSigningData, isKeetaAssetMovementAnchorCreatePersistentForwardingAddressTemplateResponse, isKeetaAssetMovementAnchorCreatePersistentForwardingResponse, isKeetaAssetMovementAnchorGetExchangeStatusResponse, isKeetaAssetMovementAnchorInitiateTransferResponse, isKeetaAssetMovementAnchorListForwardingAddressTemplateResponse, isKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse, isKeetaAssetMovementAnchorShareKYCResponse } from './common.js';
 import Resolver from "../../lib/resolver.js";
 import crypto from '../../lib/utils/crypto.js';
+import { createAssertEquals } from 'typia';
+import { addSignatureToURL } from '../../lib/http-server/common.js';
+import { SignData } from '../../lib/utils/signing.js';
+import { KeetaAnchorError } from '../../lib/error.js';
 /**
  * An opaque type that represents an Asset Movement Anchor request ID
  */
@@ -11,6 +17,125 @@ function typedAssetMovementServiceEntries(obj) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return Object.entries(obj);
 }
+const assertServiceMetadataEndpoint = (() => { const _io0 = (input, _exceptionable = true) => "string" === typeof input.url && (undefined === input.options || "object" === typeof input.options && null !== input.options && false === Array.isArray(input.options) && _io1(input.options, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["url", "options"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => (undefined === input.authentication || "object" === typeof input.authentication && null !== input.authentication && _io2(input.authentication, true && _exceptionable)) && (0 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["authentication"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => "keeta-account" === input.method && ("optional" === input.type || "required" === input.type || "none" === input.type) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["method", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.url || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".url",
+    expected: "string",
+    value: input.url
+}, _errorFactory)) && (undefined === input.options || ("object" === typeof input.options && null !== input.options && false === Array.isArray(input.options) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".options",
+    expected: "(__type.o1 | undefined)",
+    value: input.options
+}, _errorFactory)) && _ao1(input.options, _path + ".options", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".options",
+    expected: "(__type.o1 | undefined)",
+    value: input.options
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["url", "options"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => (undefined === input.authentication || ("object" === typeof input.authentication && null !== input.authentication || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".authentication",
+    expected: "(ServiceMetadataAuthenticationType | undefined)",
+    value: input.authentication
+}, _errorFactory)) && _ao2(input.authentication, _path + ".authentication", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".authentication",
+    expected: "(ServiceMetadataAuthenticationType | undefined)",
+    value: input.authentication
+}, _errorFactory)) && (0 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["authentication"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao2 = (input, _path, _exceptionable = true) => ("keeta-account" === input.method || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".method",
+    expected: "\"keeta-account\"",
+    value: input.method
+}, _errorFactory)) && ("optional" === input.type || "required" === input.type || "none" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "(\"none\" | \"optional\" | \"required\")",
+    value: input.type
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["method", "type"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const __is = (input, _exceptionable = true) => null !== input && undefined !== input && ("string" === typeof input || "object" === typeof input && null !== input && _io0(input, true)); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => (null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | string)",
+            value: input
+        }, _errorFactory)) && (undefined !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | string)",
+            value: input
+        }, _errorFactory)) && ("string" === typeof input || ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | string)",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | string)",
+            value: input
+        }, _errorFactory)))(input, "$input", true);
+    }
+    return input;
+}; })();
 function validateURL(url) {
     if (url === undefined || url === null) {
         throw (new Error('Invalid URL: null or undefined'));
@@ -18,14 +143,16 @@ function validateURL(url) {
     const parsedURL = new URL(url);
     return (parsedURL);
 }
-async function getEndpoints(resolver, request, shared) {
-    const asset = request.asset ? { asset: convertAssetSearchInputToCanonical(request.asset) } : undefined;
+async function getEndpoints(resolver, request, shared, logger) {
+    const asset = request.asset ? { asset: convertAssetOrPairSearchInputToCanonical(request.asset) } : undefined;
     const from = request.from ? { from: convertAssetLocationToString(request.from) } : {};
     const to = request.to ? { to: convertAssetLocationToString(request.to) } : {};
+    const rail = request.rail ? { rail: request.rail } : {};
     const response = await resolver.lookup('assetMovement', {
         ...asset,
         ...from,
-        ...to
+        ...to,
+        ...rail
     }, shared);
     if (response === undefined) {
         return (null);
@@ -41,13 +168,37 @@ async function getEndpoints(resolver, request, shared) {
             }
             Object.defineProperty(operationsFunctions, key, {
                 get: async function () {
-                    const url = await operation('string');
-                    return (function (params) {
-                        let substitutedURL = url;
-                        for (const [paramKey, paramValue] of Object.entries(params ?? {})) {
-                            substitutedURL = substitutedURL.replace(`{${paramKey}}`, encodeURIComponent(paramValue));
+                    const endpointInfo = assertServiceMetadataEndpoint(await Resolver.Metadata.fullyResolveValuizable(operation));
+                    let url;
+                    let authentication = {
+                        type: 'none',
+                        method: 'keeta-account'
+                    };
+                    if (typeof endpointInfo === 'string') {
+                        url = endpointInfo;
+                    }
+                    else {
+                        url = endpointInfo.url;
+                        if (endpointInfo.options?.authentication) {
+                            authentication = endpointInfo.options.authentication;
                         }
-                        return (validateURL(substitutedURL));
+                    }
+                    return ({
+                        url: function (params) {
+                            let substitutedURL;
+                            try {
+                                substitutedURL = decodeURI(url);
+                            }
+                            catch (error) {
+                                logger?.debug('getEndpoints', 'Failed to decode URI, using original URL for substitution', error, url);
+                                substitutedURL = url;
+                            }
+                            for (const [paramKey, paramValue] of Object.entries(params ?? {})) {
+                                substitutedURL = substitutedURL.replace(`{${paramKey}}`, encodeURIComponent(paramValue));
+                            }
+                            return (validateURL(substitutedURL));
+                        },
+                        options: { authentication }
                     });
                 },
                 enumerable: true,
@@ -87,7 +238,8 @@ class KeetaAssetMovementTransfer {
         this.transfer = transfer;
     }
     async getTransferStatus() {
-        return (await this.provider.getTransferStatus({ id: this.transfer.id }));
+        const account = this.request.account ? { account: this.request.account } : undefined;
+        return (await this.provider.getTransferStatus({ id: this.transfer.id, ...account }));
     }
     get transferId() {
         return (this.transfer.id);
@@ -107,115 +259,270 @@ class KeetaAssetMovementAnchorProvider extends KeetaAssetMovementAnchorBase {
         this.providerID = providerID;
         this.parent = parent;
     }
-    async initiateTransfer(request) {
-        this.logger?.debug(`Starting Asset Movement Transfer for provider ID: ${String(this.providerID)}, request: ${JSON.stringify(request)}`);
-        const endpoints = this.serviceInfo.operations;
-        const initiateTransfer = await endpoints.initiateTransfer;
-        if (initiateTransfer === undefined) {
-            throw (new Error('Asset Movement service does not support initiateTransfer operation'));
+    async #getOperationData(operationName, params) {
+        const endpoint = await this.serviceInfo.operations[operationName];
+        if (endpoint === undefined) {
+            throw (new Error(`Asset Movement service does not support ${operationName} operation`));
         }
-        const initiateTransferURL = initiateTransfer();
-        const requestInformation = await fetch(initiateTransferURL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json'
-            },
-            body: JSON.stringify({
-                ...request
-            })
+        if (endpoint.options.authentication.method !== 'keeta-account') {
+            throw (new Error(`Unsupported authentication method: ${endpoint.options.authentication.method}`));
+        }
+        return ({
+            url: endpoint.url(params),
+            auth: endpoint.options.authentication
+        });
+    }
+    async #makeRequest(input) {
+        const { url, auth } = await this.#getOperationData(input.endpoint, input.params);
+        let serializedRequest;
+        if (input.body && input.serializeRequest) {
+            serializedRequest = await input.serializeRequest(input.body);
+        }
+        else {
+            serializedRequest = input.body;
+        }
+        let signed;
+        if (auth.type === 'required' || (auth.type === 'optional' && input.account)) {
+            if (!input.account) {
+                throw (new Error('Account information is required for this operation'));
+            }
+            if (!input.getSignedData) {
+                throw (new Error('getSignedData function is required for signing the request'));
+            }
+            // We need this assertion because TypeScript cannot infer that the type is correct here, it is correct in the arguments.
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const signable = input.getSignedData(serializedRequest);
+            signed = await SignData(input.account.assertAccount(), signable);
+        }
+        let usingUrl = url;
+        const headers = {
+            'Accept': 'application/json'
+        };
+        let body = null;
+        if (input.method === 'POST') {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify({ ...serializedRequest, signed });
+        }
+        else {
+            if (signed) {
+                if (!input.account) {
+                    throw (new Error('invariant: Account information is required for this operation, which should exist at this point'));
+                }
+                usingUrl = addSignatureToURL(usingUrl, { signedField: signed, account: input.account.assertAccount() });
+            }
+            if (input.body) {
+                throw (new Error('Body cannot be sent with GET requests'));
+            }
+        }
+        const requestInformation = await fetch(usingUrl, {
+            method: input.method, headers, body
         });
         const requestInformationJSON = await requestInformation.json();
-        if (!isKeetaAssetMovementAnchorInitiateTransferResponse(requestInformationJSON)) {
+        if (!input.isResponse(requestInformationJSON)) {
             throw (new Error(`Invalid response from asset movement service: ${JSON.stringify(requestInformationJSON)}`));
         }
         if (!requestInformationJSON.ok) {
-            throw (new Error(`asset movement request failed: ${requestInformationJSON.error}`));
+            let errorStr;
+            let parsedError = null;
+            try {
+                parsedError = await KeetaAnchorError.fromJSON(requestInformationJSON);
+            }
+            catch (error) {
+                this.logger?.debug('Failed to parse error response as KeetaAnchorError', error, requestInformationJSON);
+            }
+            if (parsedError) {
+                throw (parsedError);
+            }
+            else {
+                if ('error' in requestInformationJSON && typeof requestInformationJSON.error === 'string') {
+                    errorStr = requestInformationJSON.error;
+                }
+                else {
+                    errorStr = 'Unknown error';
+                }
+                throw (new Error(`asset movement ${input.endpoint} request failed: ${errorStr}`));
+            }
         }
+        // We need this assertion because TypeScript cannot infer that the type is correct here, it is correct because we checked it above.
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return requestInformationJSON;
+    }
+    async initiateTransfer(request) {
+        this.logger?.debug(`Starting Asset Movement Transfer for provider ID: ${String(this.providerID)}`);
+        const requestInformationJSON = await this.#makeRequest({
+            method: 'POST',
+            endpoint: 'initiateTransfer',
+            account: request.account,
+            serializeRequest(body) {
+                return ({
+                    ...body,
+                    value: String(body.value),
+                    from: {
+                        location: convertAssetLocationToString(body.from.location)
+                    },
+                    to: {
+                        location: convertAssetLocationToString(body.to.location),
+                        recipient: body.to.recipient
+                    },
+                    asset: convertAssetOrPairSearchInputToCanonical(body.asset),
+                    account: body.account?.assertAccount().publicKeyString.get()
+                });
+            },
+            body: request,
+            getSignedData: getKeetaAssetMovementAnchorInitiateTransferRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorInitiateTransferResponse
+        });
         this.logger?.debug(`asset movement request successful, request ID ${requestInformationJSON.id}`);
         const anchorTransfer = new KeetaAssetMovementTransfer(this, request, { id: requestInformationJSON.id, instructionChoices: requestInformationJSON.instructionChoices });
         return (anchorTransfer);
     }
     async getTransferStatus(request) {
-        const endpoints = this.serviceInfo.operations;
-        const getTransferStatus = await endpoints.getTransferStatus;
-        if (getTransferStatus === undefined) {
-            throw (new Error('Asset Movement service does not support getTransferStatus operation'));
-        }
-        const getTransferURL = getTransferStatus({ id: request.id });
-        const requestInformation = await fetch(getTransferURL, {
+        const requestInformationJSON = await this.#makeRequest({
             method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json'
-            }
+            endpoint: 'getTransferStatus',
+            account: request.account,
+            params: { id: request.id },
+            getSignedData: () => getKeetaAssetMovementAnchorGetTransferStatusRequestSigningData(request),
+            isResponse: isKeetaAssetMovementAnchorGetExchangeStatusResponse
         });
-        const requestInformationJSON = await requestInformation.json();
-        if (!isKeetaAssetMovementAnchorGetExchangeStatusResponse(requestInformationJSON)) {
-            throw (new Error(`Invalid response from asset movement service: ${JSON.stringify(requestInformationJSON)}`));
-        }
-        if (!requestInformationJSON.ok) {
-            throw (new Error(`asset movement request failed: ${requestInformationJSON.error}`));
-        }
         this.logger?.debug(`asset movement request successful, request ID ${request.id}`);
         return (requestInformationJSON);
     }
+    async createPersistentForwardingTemplate(request) {
+        this.logger?.debug(`Creating persistent forwarding for provider ID: ${String(this.providerID)}, request: ${JSON.stringify(request)}`);
+        const requestInformationJSON = await this.#makeRequest({
+            method: 'POST',
+            endpoint: 'createPersistentForwardingTemplate',
+            account: request.account,
+            serializeRequest(body) {
+                return ({
+                    ...body,
+                    location: convertAssetLocationToString(body.location),
+                    asset: convertAssetOrPairSearchInputToCanonical(body.asset),
+                    account: body.account?.assertAccount().publicKeyString.get()
+                });
+            },
+            body: request,
+            getSignedData: getKeetaAssetMovementAnchorCreatePersistentForwardingAddressTemplateRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorCreatePersistentForwardingAddressTemplateResponse
+        });
+        this.logger?.debug(`create persistent forwarding request successful`, requestInformationJSON.address);
+        return (requestInformationJSON);
+    }
     async createPersistentForwardingAddress(request) {
         this.logger?.debug(`Creating persistent forwarding for provider ID: ${String(this.providerID)}, request: ${JSON.stringify(request)}`);
-        const endpoints = this.serviceInfo.operations;
-        const createPersistentForwarding = await endpoints.createPersistentForwarding;
-        if (createPersistentForwarding === undefined) {
-            throw (new Error('Asset Movement service does not support createPersistentForwarding operation'));
-        }
-        const createPersistentForwardingURL = createPersistentForwarding();
-        const requestInformation = await fetch(createPersistentForwardingURL, {
+        const requestInformationJSON = await this.#makeRequest({
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json'
+            endpoint: 'createPersistentForwarding',
+            account: request.account,
+            serializeRequest(body) {
+                const base = {
+                    sourceLocation: convertAssetLocationToString(body.sourceLocation),
+                    asset: convertAssetOrPairSearchInputToCanonical(body.asset),
+                    account: body.account?.assertAccount().publicKeyString.get()
+                };
+                if ('persistentAddressTemplateId' in body) {
+                    return ({
+                        ...base,
+                        persistentAddressTemplateId: body.persistentAddressTemplateId
+                    });
+                }
+                else {
+                    return ({
+                        ...base,
+                        destinationAddress: body.destinationAddress,
+                        destinationLocation: convertAssetLocationToString(body.destinationLocation)
+                    });
+                }
             },
-            body: JSON.stringify({
-                ...request
-            })
+            body: request,
+            getSignedData: getKeetaAssetMovementAnchorCreatePersistentForwardingRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorCreatePersistentForwardingResponse
         });
-        const requestInformationJSON = await requestInformation.json();
-        if (!isKeetaAssetMovementAnchorCreatePersistentForwardingResponse(requestInformationJSON)) {
-            throw (new Error(`Invalid response from create persistent forwarding request: ${JSON.stringify(requestInformationJSON)}`));
-        }
-        if (!requestInformationJSON.ok) {
-            throw (new Error(`create persistent forwarding request failed: ${requestInformationJSON.error}`));
-        }
-        this.logger?.debug(`create persistent forwarding request successful, ${requestInformationJSON.address}`);
+        this.logger?.debug(`create persistent forwarding request successful`, requestInformationJSON.address);
         return (requestInformationJSON);
     }
+    async listForwardingAddressTemplates(request) {
+        this.logger?.debug(`Listing persistent forwarding address templates for provider ID: ${String(this.providerID)}`);
+        const requestInformationJSON = await this.#makeRequest({
+            method: 'POST',
+            endpoint: 'listPersistentForwardingTemplate',
+            account: request.account,
+            body: request,
+            serializeRequest(body) {
+                return ({
+                    account: body.account?.assertAccount().publicKeyString.get(),
+                    asset: body.asset?.map(a => convertAssetSearchInputToCanonical(a)),
+                    location: body.location?.map(l => convertAssetLocationToString(l))
+                });
+            },
+            getSignedData: getKeetaAssetMovementAnchorListForwardingAddressTemplateRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorListForwardingAddressTemplateResponse
+        });
+        this.logger?.debug(`list persistent forwarding address templates request successful`, requestInformationJSON.templates);
+        return (requestInformationJSON.templates);
+    }
     async listTransactions(request) {
         this.logger?.debug(`List persistent forwarding transactions provider ID: ${String(this.providerID)}, request: ${JSON.stringify(request)}`);
-        const endpoints = this.serviceInfo.operations;
-        const listTransactions = await endpoints.listTransactions;
-        if (listTransactions === undefined) {
-            throw (new Error('Asset Movement service does not support listTransactions operation'));
-        }
-        const listTransactionsURL = listTransactions();
-        const requestInformation = await fetch(listTransactionsURL, {
+        const requestInformationJSON = await this.#makeRequest({
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json'
+            endpoint: 'listTransactions',
+            account: request.account,
+            serializeRequest(body) {
+                return ({
+                    account: body.account?.assertAccount().publicKeyString.get(),
+                    pagination: body.pagination,
+                    persistentAddresses: body.persistentAddresses?.map(pa => ({
+                        location: convertAssetLocationToString(pa.location),
+                        ...('persistentAddressTemplate' in pa ?
+                            { persistentAddressTemplate: pa.persistentAddressTemplate } :
+                            { persistentAddress: pa.persistentAddress })
+                    })),
+                    from: body.from ? {
+                        location: convertAssetLocationToString(body.from.location),
+                        userAddress: body.from.userAddress,
+                        asset: body.from.asset ? convertAssetSearchInputToCanonical(body.from.asset) : undefined
+                    } : undefined,
+                    to: body.to ? {
+                        location: convertAssetLocationToString(body.to.location),
+                        userAddress: body.to.userAddress,
+                        asset: body.to.asset ? convertAssetSearchInputToCanonical(body.to.asset) : undefined
+                    } : undefined
+                });
             },
-            body: JSON.stringify({
-                ...request
-            })
+            body: request,
+            getSignedData: getKeetaAssetMovementAnchorlistTransactionsRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse
         });
-        const requestInformationJSON = await requestInformation.json();
-        if (!isKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse(requestInformationJSON)) {
-            throw (new Error(`Invalid response from list persistent transactions request: ${JSON.stringify(requestInformationJSON)}`));
-        }
-        if (!requestInformationJSON.ok) {
-            throw (new Error(`list persistent transactions request failed: ${requestInformationJSON.error}`));
-        }
         this.logger?.debug(`list persistent transactions request successful, ${requestInformationJSON.transactions}`);
         return (requestInformationJSON);
     }
+    async shareKYCAttributes(request) {
+        this.logger?.debug('Sharing KYC attributes');
+        await this.#makeRequest({
+            method: 'POST',
+            endpoint: 'shareKYC',
+            account: request.account,
+            async serializeRequest(body) {
+                let attributes;
+                if (typeof body.attributes === 'string') {
+                    attributes = body.attributes;
+                }
+                else {
+                    attributes = await body.attributes.export({ format: 'string' });
+                }
+                return ({
+                    account: body.account.assertAccount().publicKeyString.get(),
+                    attributes: attributes,
+                    tosAgreement: body.tosAgreement
+                });
+            },
+            body: request,
+            getSignedData: getKeetaAssetMovementAnchorShareKYCRequestSigningData,
+            isResponse: isKeetaAssetMovementAnchorShareKYCResponse
+        });
+        this.logger?.debug(`done sharing KYC attributes`);
+    }
 }
 class KeetaAssetMovementAnchorClient extends KeetaAssetMovementAnchorBase {
     resolver;
@@ -251,7 +558,7 @@ class KeetaAssetMovementAnchorClient extends KeetaAssetMovementAnchorBase {
         }
     }
     async #lookup(request, shared) {
-        const endpoints = await getEndpoints(this.resolver, request, shared);
+        const endpoints = await getEndpoints(this.resolver, request, shared, this.logger);
         if (endpoints === null) {
             return (null);
         }