@bitgo-beta/sdk-api 1.10.1-beta.184 → 1.10.1-beta.1841

package/dist/test/unit/api.js

@@ -0,0 +1,307 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const src_1 = require("../../src");
+describe('bitgo:api unit tests', function () {
+    describe('serializeRequestData', function () {
+        it('should return string data as-is for v4 raw body support', function () {
+            const stringBody = '{"address":  "tb1qtest",   "amount":100000}';
+            const mockReq = {
+                _data: stringBody,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, stringBody);
+            // Verify _data was not modified
+            assert.strictEqual(mockReq._data, stringBody);
+        });
+        it('should return empty string as-is', function () {
+            const mockReq = {
+                _data: '',
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, '');
+        });
+        it('should convert Buffer to UTF-8 string and mutate _data', function () {
+            const jsonString = '{"address":"tb1qtest","amount":100000}';
+            const bufferBody = Buffer.from(jsonString, 'utf8');
+            const mockReq = {
+                _data: bufferBody,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(typeof result, 'string');
+            assert.strictEqual(result, jsonString);
+            // Verify _data WAS mutated to string - critical for superagent to send correct bytes
+            assert.strictEqual(typeof mockReq._data, 'string');
+            assert.strictEqual(mockReq._data, jsonString);
+        });
+        it('should convert empty Buffer to empty string and mutate _data', function () {
+            const mockReq = {
+                _data: Buffer.from(''),
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(typeof result, 'string');
+            assert.strictEqual(result, '');
+            // Verify _data WAS mutated to string
+            assert.strictEqual(typeof mockReq._data, 'string');
+            assert.strictEqual(mockReq._data, '');
+        });
+        it('should produce identical results on retry for HMAC consistency', function () {
+            const jsonString = '{"address":"tb1qtest","amount":100000}';
+            const bufferBody = Buffer.from(jsonString, 'utf8');
+            const mockReq = {
+                _data: bufferBody,
+                get: () => 'application/json',
+            };
+            // First call (original request) - converts Buffer to string, mutates _data
+            const result1 = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result1, jsonString);
+            assert.strictEqual(typeof mockReq._data, 'string');
+            // Second call (simulating retry) - _data is now a string, returns as-is
+            const result2 = (0, src_1.serializeRequestData)(mockReq);
+            // Both calls should return identical strings for consistent HMAC
+            assert.strictEqual(result1, result2);
+            assert.strictEqual(result2, jsonString);
+            // _data should now be a string (mutated on first call)
+            assert.strictEqual(typeof mockReq._data, 'string');
+            assert.strictEqual(mockReq._data, jsonString);
+        });
+        it('should mutate Buffer to prevent superagent JSON serialization', function () {
+            // This test verifies the critical behavior: if we don't mutate _data from Buffer to string,
+            // superagent will serialize the Buffer as {"type":"Buffer","data":[...]}, which won't match
+            // the HMAC calculated on the UTF-8 string. By mutating _data, we ensure superagent sends
+            // the exact bytes we used for HMAC calculation.
+            const jsonString = '{"address":"tb1qtest","amount":100000}';
+            const bufferBody = Buffer.from(jsonString, 'utf8');
+            const mockReq = {
+                _data: bufferBody,
+                get: () => 'application/json',
+            };
+            (0, src_1.serializeRequestData)(mockReq);
+            // After serialization, _data MUST be a string, not a Buffer
+            assert.strictEqual(typeof mockReq._data, 'string');
+            assert.strictEqual(mockReq._data, jsonString);
+            // This ensures when superagent sends the request, it sends the UTF-8 string,
+            // not the JSON-serialized Buffer representation.
+        });
+        it('should serialize object data to JSON', function () {
+            const objectBody = { address: 'tb1qtest', amount: 100000 };
+            const mockReq = {
+                _data: objectBody,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, JSON.stringify(objectBody));
+            // Verify _data was updated to serialized form
+            assert.strictEqual(mockReq._data, JSON.stringify(objectBody));
+        });
+        it('should handle nested objects', function () {
+            const nestedBody = { level1: { level2: { value: 'deep' } } };
+            const mockReq = {
+                _data: nestedBody,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, JSON.stringify(nestedBody));
+        });
+        it('should return undefined for undefined data', function () {
+            const mockReq = {
+                _data: undefined,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, undefined);
+        });
+        it('should return undefined for null data', function () {
+            const mockReq = {
+                _data: null,
+                get: () => 'application/json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, undefined);
+        });
+        it('should handle Content-Type with charset', function () {
+            const objectBody = { test: 'value' };
+            const mockReq = {
+                _data: objectBody,
+                get: () => 'application/json; charset=utf-8',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, JSON.stringify(objectBody));
+        });
+        it('should handle application/vnd.api+json content type', function () {
+            const objectBody = { data: 'test' };
+            const mockReq = {
+                _data: objectBody,
+                get: () => 'application/vnd.api+json',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            assert.strictEqual(result, JSON.stringify(objectBody));
+        });
+        it('should return undefined for unsupported content type without serializer', function () {
+            const objectBody = { test: 'value' };
+            const mockReq = {
+                _data: objectBody,
+                get: () => 'text/plain',
+            };
+            const result = (0, src_1.serializeRequestData)(mockReq);
+            // text/plain doesn't have a JSON serializer, so returns undefined
+            assert.strictEqual(result, undefined);
+        });
+    });
+    describe('handleResponseResult', function () {
+        it('should return text for text-based responses', function () {
+            const csvText = `transactionId,date,amount,currency,status
+        12345,2025-01-15,100.00,USD,completed
+        67890,2025-01-22,50.50,EUR,completed
+        13579,2025-02-10,200.00,USD,pending
+        24680,2025-02-28,75.25,BTC,completed`;
+            const response = {
+                status: 200,
+                header: { 'content-type': 'text/csv' },
+                text: csvText,
+            };
+            const result = (0, src_1.handleResponseResult)()(response);
+            assert.strictEqual(result, response.text);
+        });
+        it('should parse JSON response and return the entire body if no field is specified', function () {
+            const response = {
+                status: 200,
+                header: { 'content-type': 'application/json' },
+                body: { foo: 'bar', baz: 123 },
+            };
+            const result = (0, src_1.handleResponseResult)()(response);
+            assert.deepStrictEqual(result, response.body);
+        });
+        it('should parse JSON response and return the specified field if provided', function () {
+            const response = {
+                status: 200,
+                header: { 'content-type': 'application/json' },
+                body: { foo: 'bar', baz: 123 },
+            };
+            const result = (0, src_1.handleResponseResult)('foo')(response);
+            assert.strictEqual(result, 'bar');
+        });
+        it('should return the entire response for non-JSON and non-text responses', function () {
+            const response = {
+                status: 200,
+                header: { 'content-type': 'image/png' },
+                blob: 'abcdefghijk',
+            };
+            const result = (0, src_1.handleResponseResult)()(response);
+            assert.strictEqual(result, response);
+        });
+        it('should return the full body if this field exists', function () {
+            const response = {
+                status: 200,
+                header: { 'content-type': 'application/octet-stream' },
+                body: { irrelevant: true },
+            };
+            const result = (0, src_1.handleResponseResult)()(response);
+            assert.strictEqual(result, response.body);
+        });
+    });
+    describe('handleResponseError', function () {
+        it('should re-throw an error without response property', function () {
+            const originalError = new Error('Han shot first');
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), { name: 'Error', message: 'Han shot first' });
+        });
+        it('should use the status code if the response has no error text', function () {
+            const originalError = new Error();
+            originalError.response = { status: 400 };
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), {
+                name: 'ApiResponseError',
+                message: '400',
+                invalidToken: false,
+                needsOTP: false,
+                result: undefined,
+                status: 400,
+            });
+        });
+        it('should use the response body.error text', function () {
+            const originalError = new Error();
+            originalError.response = { status: 400, body: { error: 'Han shot first' } };
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), {
+                name: 'ApiResponseError',
+                message: 'Han shot first',
+                invalidToken: false,
+                needsOTP: false,
+                result: originalError.response.body,
+                status: 400,
+            });
+        });
+        it('should parse HTML code from the response text', function () {
+            const originalError = new Error();
+            originalError.response = { status: 400, text: ' <b> Han shot first </b>' };
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), {
+                name: 'ApiResponseError',
+                message: '400\nHan shot first',
+                invalidToken: false,
+                needsOTP: false,
+                result: undefined,
+                status: 400,
+            });
+        });
+        it('should annotate invalidToken property', function () {
+            const originalError = new Error();
+            originalError.response = { status: 400, header: { 'x-auth-required': 'true' } };
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), {
+                name: 'ApiResponseError',
+                message: '400',
+                invalidToken: true,
+                needsOTP: false,
+                result: undefined,
+                status: 400,
+            });
+        });
+        it('should annotate needsOTP property', function () {
+            const originalError = new Error();
+            originalError.response = { status: 400, body: { needsOTP: true } };
+            assert.throws(() => (0, src_1.handleResponseError)(originalError), {
+                name: 'ApiResponseError',
+                message: '400',
+                invalidToken: false,
+                needsOTP: true,
+                result: originalError.response.body,
+                status: 400,
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../test/unit/api.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport { handleResponseError, handleResponseResult, serializeRequestData } from '../../src';\n\ndescribe('bitgo:api unit tests', function () {\n  describe('serializeRequestData', function () {\n    it('should return string data as-is for v4 raw body support', function () {\n      const stringBody = '{\"address\":  \"tb1qtest\",   \"amount\":100000}';\n      const mockReq: any = {\n        _data: stringBody,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, stringBody);\n      // Verify _data was not modified\n      assert.strictEqual(mockReq._data, stringBody);\n    });\n\n    it('should return empty string as-is', function () {\n      const mockReq: any = {\n        _data: '',\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, '');\n    });\n\n    it('should convert Buffer to UTF-8 string and mutate _data', function () {\n      const jsonString = '{\"address\":\"tb1qtest\",\"amount\":100000}';\n      const bufferBody = Buffer.from(jsonString, 'utf8');\n      const mockReq: any = {\n        _data: bufferBody,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(typeof result, 'string');\n      assert.strictEqual(result, jsonString);\n      // Verify _data WAS mutated to string - critical for superagent to send correct bytes\n      assert.strictEqual(typeof mockReq._data, 'string');\n      assert.strictEqual(mockReq._data, jsonString);\n    });\n\n    it('should convert empty Buffer to empty string and mutate _data', function () {\n      const mockReq: any = {\n        _data: Buffer.from(''),\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(typeof result, 'string');\n      assert.strictEqual(result, '');\n      // Verify _data WAS mutated to string\n      assert.strictEqual(typeof mockReq._data, 'string');\n      assert.strictEqual(mockReq._data, '');\n    });\n\n    it('should produce identical results on retry for HMAC consistency', function () {\n      const jsonString = '{\"address\":\"tb1qtest\",\"amount\":100000}';\n      const bufferBody = Buffer.from(jsonString, 'utf8');\n      const mockReq: any = {\n        _data: bufferBody,\n        get: () => 'application/json',\n      };\n\n      // First call (original request) - converts Buffer to string, mutates _data\n      const result1 = serializeRequestData(mockReq);\n      assert.strictEqual(result1, jsonString);\n      assert.strictEqual(typeof mockReq._data, 'string');\n\n      // Second call (simulating retry) - _data is now a string, returns as-is\n      const result2 = serializeRequestData(mockReq);\n\n      // Both calls should return identical strings for consistent HMAC\n      assert.strictEqual(result1, result2);\n      assert.strictEqual(result2, jsonString);\n      // _data should now be a string (mutated on first call)\n      assert.strictEqual(typeof mockReq._data, 'string');\n      assert.strictEqual(mockReq._data, jsonString);\n    });\n\n    it('should mutate Buffer to prevent superagent JSON serialization', function () {\n      // This test verifies the critical behavior: if we don't mutate _data from Buffer to string,\n      // superagent will serialize the Buffer as {\"type\":\"Buffer\",\"data\":[...]}, which won't match\n      // the HMAC calculated on the UTF-8 string. By mutating _data, we ensure superagent sends\n      // the exact bytes we used for HMAC calculation.\n      const jsonString = '{\"address\":\"tb1qtest\",\"amount\":100000}';\n      const bufferBody = Buffer.from(jsonString, 'utf8');\n      const mockReq: any = {\n        _data: bufferBody,\n        get: () => 'application/json',\n      };\n\n      serializeRequestData(mockReq);\n\n      // After serialization, _data MUST be a string, not a Buffer\n      assert.strictEqual(typeof mockReq._data, 'string');\n      assert.strictEqual(mockReq._data, jsonString);\n\n      // This ensures when superagent sends the request, it sends the UTF-8 string,\n      // not the JSON-serialized Buffer representation.\n    });\n\n    it('should serialize object data to JSON', function () {\n      const objectBody = { address: 'tb1qtest', amount: 100000 };\n      const mockReq: any = {\n        _data: objectBody,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, JSON.stringify(objectBody));\n      // Verify _data was updated to serialized form\n      assert.strictEqual(mockReq._data, JSON.stringify(objectBody));\n    });\n\n    it('should handle nested objects', function () {\n      const nestedBody = { level1: { level2: { value: 'deep' } } };\n      const mockReq: any = {\n        _data: nestedBody,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, JSON.stringify(nestedBody));\n    });\n\n    it('should return undefined for undefined data', function () {\n      const mockReq: any = {\n        _data: undefined,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, undefined);\n    });\n\n    it('should return undefined for null data', function () {\n      const mockReq: any = {\n        _data: null,\n        get: () => 'application/json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, undefined);\n    });\n\n    it('should handle Content-Type with charset', function () {\n      const objectBody = { test: 'value' };\n      const mockReq: any = {\n        _data: objectBody,\n        get: () => 'application/json; charset=utf-8',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, JSON.stringify(objectBody));\n    });\n\n    it('should handle application/vnd.api+json content type', function () {\n      const objectBody = { data: 'test' };\n      const mockReq: any = {\n        _data: objectBody,\n        get: () => 'application/vnd.api+json',\n      };\n\n      const result = serializeRequestData(mockReq);\n      assert.strictEqual(result, JSON.stringify(objectBody));\n    });\n\n    it('should return undefined for unsupported content type without serializer', function () {\n      const objectBody = { test: 'value' };\n      const mockReq: any = {\n        _data: objectBody,\n        get: () => 'text/plain',\n      };\n\n      const result = serializeRequestData(mockReq);\n      // text/plain doesn't have a JSON serializer, so returns undefined\n      assert.strictEqual(result, undefined);\n    });\n  });\n\n  describe('handleResponseResult', function () {\n    it('should return text for text-based responses', function () {\n      const csvText = `transactionId,date,amount,currency,status\n        12345,2025-01-15,100.00,USD,completed\n        67890,2025-01-22,50.50,EUR,completed\n        13579,2025-02-10,200.00,USD,pending\n        24680,2025-02-28,75.25,BTC,completed`;\n\n      const response: any = {\n        status: 200,\n        header: { 'content-type': 'text/csv' },\n        text: csvText,\n      };\n\n      const result = handleResponseResult()(response);\n      assert.strictEqual(result, response.text);\n    });\n\n    it('should parse JSON response and return the entire body if no field is specified', function () {\n      const response: any = {\n        status: 200,\n        header: { 'content-type': 'application/json' },\n        body: { foo: 'bar', baz: 123 },\n      };\n\n      const result = handleResponseResult()(response);\n      assert.deepStrictEqual(result, response.body);\n    });\n\n    it('should parse JSON response and return the specified field if provided', function () {\n      const response: any = {\n        status: 200,\n        header: { 'content-type': 'application/json' },\n        body: { foo: 'bar', baz: 123 },\n      };\n\n      const result = handleResponseResult('foo')(response);\n      assert.strictEqual(result, 'bar');\n    });\n\n    it('should return the entire response for non-JSON and non-text responses', function () {\n      const response: any = {\n        status: 200,\n        header: { 'content-type': 'image/png' },\n        blob: 'abcdefghijk',\n      };\n\n      const result = handleResponseResult()(response);\n      assert.strictEqual(result, response);\n    });\n\n    it('should return the full body if this field exists', function () {\n      const response: any = {\n        status: 200,\n        header: { 'content-type': 'application/octet-stream' },\n        body: { irrelevant: true },\n      };\n\n      const result = handleResponseResult()(response);\n      assert.strictEqual(result, response.body);\n    });\n  });\n\n  describe('handleResponseError', function () {\n    it('should re-throw an error without response property', function () {\n      const originalError = new Error('Han shot first');\n      assert.throws(() => handleResponseError(originalError), { name: 'Error', message: 'Han shot first' });\n    });\n\n    it('should use the status code if the response has no error text', function () {\n      const originalError: any = new Error();\n      originalError.response = { status: 400 };\n      assert.throws(() => handleResponseError(originalError), {\n        name: 'ApiResponseError',\n        message: '400',\n        invalidToken: false,\n        needsOTP: false,\n        result: undefined,\n        status: 400,\n      });\n    });\n\n    it('should use the response body.error text', function () {\n      const originalError: any = new Error();\n      originalError.response = { status: 400, body: { error: 'Han shot first' } };\n      assert.throws(() => handleResponseError(originalError), {\n        name: 'ApiResponseError',\n        message: 'Han shot first',\n        invalidToken: false,\n        needsOTP: false,\n        result: originalError.response.body,\n        status: 400,\n      });\n    });\n\n    it('should parse HTML code from the response text', function () {\n      const originalError: any = new Error();\n      originalError.response = { status: 400, text: ' <b> Han shot first </b>' };\n      assert.throws(() => handleResponseError(originalError), {\n        name: 'ApiResponseError',\n        message: '400\\nHan shot first',\n        invalidToken: false,\n        needsOTP: false,\n        result: undefined,\n        status: 400,\n      });\n    });\n\n    it('should annotate invalidToken property', function () {\n      const originalError: any = new Error();\n      originalError.response = { status: 400, header: { 'x-auth-required': 'true' } };\n      assert.throws(() => handleResponseError(originalError), {\n        name: 'ApiResponseError',\n        message: '400',\n        invalidToken: true,\n        needsOTP: false,\n        result: undefined,\n        status: 400,\n      });\n    });\n\n    it('should annotate needsOTP property', function () {\n      const originalError: any = new Error();\n      originalError.response = { status: 400, body: { needsOTP: true } };\n      assert.throws(() => handleResponseError(originalError), {\n        name: 'ApiResponseError',\n        message: '400',\n        invalidToken: false,\n        needsOTP: true,\n        result: originalError.response.body,\n        status: 400,\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgoAPI.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=bitgoAPI.d.ts.map

package/dist/test/unit/bitgoAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitgoAPI.d.ts","sourceRoot":"","sources":["../../../test/unit/bitgoAPI.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,CAAC"}