@airgap/stellar 0.13.41-beta.0 → 0.13.41-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airgap/stellar",
-  "version": "0.13.41-beta.0",
+  "version": "0.13.41-beta.11",
   "description": "The @airgap/aeternity is an Aeternity implementation of the ICoinProtocol interface from @airgap/coinlib-core.",
   "keywords": [
     "airgap",
@@ -24,15 +24,15 @@
     "lint:prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint-ci": "tslint -t json -o ../../lint-reports/aeternity.json --project . || true",
     "lint-ci:prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --list-different",
-    "test": "",
-    "test-ci": "",
+    "test": "TS_NODE_PROJECT='./test/tsconfig.json' nyc mocha --bail --require ts-node/register --require tsconfig-paths/register --require source-map-support/register --full-trace --delay --timeout 40000 ./test/**/**.spec.ts",
+    "test-ci": "nyc --reporter=lcov npm test",
     "browserify": "browserify ./dist/index.js -s airgapCoinLibAeternity > ./dist/airgap-coinlib-aeternity.min.js"
   },
   "author": "Papers AG <contact@papers.ch> (https://papers.ch)",
   "dependencies": {
-    "@airgap/coinlib-core": "^0.13.41-beta.0",
-    "@airgap/module-kit": "^0.13.41-beta.0",
-    "@airgap/serializer": "^0.13.41-beta.0",
+    "@airgap/coinlib-core": "^0.13.41-beta.11",
+    "@airgap/module-kit": "^0.13.41-beta.11",
+    "@airgap/serializer": "^0.13.41-beta.11",
     "@stellar/stellar-sdk": "^13.3.0"
   },
   "localDependencies": {},

package/v1/data/StellarAddress.d.ts

@@ -2,8 +2,7 @@ import { PublicKey } from '@airgap/module-kit';
 export declare class StellarAddress {
     private readonly value;
     private constructor();
-    static from(publicKey: string | PublicKey): StellarAddress;
+    static from(publicKey: PublicKey): StellarAddress;
     asString(): string;
     toPublicKey(): PublicKey;
-    private static parse;
 }

package/v1/data/StellarAddress.js

@@ -8,8 +8,12 @@ var StellarAddress = /** @class */ (function () {
         this.value = value;
     }
     StellarAddress.from = function (publicKey) {
-        var _publicKey = typeof publicKey === 'string' ? StellarAddress.parse(publicKey) : publicKey;
-        return new StellarAddress(_publicKey.value);
+        if (stellar_sdk_1.StrKey.isValidEd25519PublicKey(publicKey.value)) {
+            return new StellarAddress(publicKey.value);
+        }
+        var rawPublicKey = Buffer.from(publicKey.value, 'hex');
+        var stellarAddress = stellar_sdk_1.StrKey.encodeEd25519PublicKey(rawPublicKey);
+        return new StellarAddress(stellarAddress);
     };
     StellarAddress.prototype.asString = function () {
         return this.value;
@@ -17,13 +21,6 @@ var StellarAddress = /** @class */ (function () {
     StellarAddress.prototype.toPublicKey = function () {
         return (0, module_kit_1.newPublicKey)(this.value, 'encoded');
     };
-    StellarAddress.parse = function (value) {
-        // Validate it's a proper Stellar G-address
-        if (!stellar_sdk_1.StrKey.isValidEd25519PublicKey(value)) {
-            throw new Error('Invalid Stellar address');
-        }
-        return (0, module_kit_1.newPublicKey)(value, 'encoded');
-    };
     return StellarAddress;
 }());
 exports.StellarAddress = StellarAddress;

package/v1/data/StellarAddress.js.map

@@ -1 +1 @@
-{"version":3,"file":"StellarAddress.js","sourceRoot":"","sources":["../../../src/v1/data/StellarAddress.ts"],"names":[],"mappings":";;;AAAA,iDAA4D;AAE5D,oDAA6C;AAE7C;IACE,wBAAqC,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;IAExC,mBAAI,GAAlB,UAAmB,SAA6B;QAC9C,IAAM,UAAU,GAAc,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;QAEzG,OAAO,IAAI,cAAc,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;IAC7C,CAAC;IAEM,iCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAEM,oCAAW,GAAlB;QACE,OAAO,IAAA,yBAAY,EAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAC5C,CAAC;IAEc,oBAAK,GAApB,UAAqB,KAAa;QAChC,2CAA2C;QAC3C,IAAI,CAAC,oBAAM,CAAC,uBAAuB,CAAC,KAAK,CAAC,EAAE;YAC1C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;SAC3C;QAED,OAAO,IAAA,yBAAY,EAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IACvC,CAAC;IACH,qBAAC;AAAD,CAAC,AAzBD,IAyBC;AAzBY,wCAAc"}
+{"version":3,"file":"StellarAddress.js","sourceRoot":"","sources":["../../../src/v1/data/StellarAddress.ts"],"names":[],"mappings":";;;AAAA,iDAA4D;AAE5D,oDAA6C;AAE7C;IACE,wBAAqC,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;IAExC,mBAAI,GAAlB,UAAmB,SAAoB;QACrC,IAAI,oBAAM,CAAC,uBAAuB,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YACnD,OAAO,IAAI,cAAc,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;SAC3C;QAED,IAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAExD,IAAM,cAAc,GAAG,oBAAM,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAA;QAElE,OAAO,IAAI,cAAc,CAAC,cAAc,CAAC,CAAA;IAC3C,CAAC;IAEM,iCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAEM,oCAAW,GAAlB;QACE,OAAO,IAAA,yBAAY,EAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAC5C,CAAC;IACH,qBAAC;AAAD,CAAC,AAtBD,IAsBC;AAtBY,wCAAc"}

package/v1/index.d.ts

@@ -1,13 +1,14 @@
 import { StellarBlockExplorer } from './block-explorer/StellarBlockExplorer';
 import { StellarModule } from './module/StellarModule';
+import { createStellarAssetProtocol, StellarAssetProtocol } from './protocol/stellarAssets/StellarAsset';
 import { StellarProtocol, createStellarProtocol, createStellarProtocolOptions } from './protocol/StellarProtocol';
 import { StellarTransactionSignRequest } from './serializer/v3/schemas/definitions/transaction-sign-request-stellar';
 import { StellarTransactionSignResponse } from './serializer/v3/schemas/definitions/transaction-sign-response-stellar';
 import { StellarCryptoConfiguration } from './types/crypto';
-import { StellarProtocolNetwork, StellarProtocolOptions, StellarUnits } from './types/protocol';
+import { StellarAssetMetadata, StellarProtocolNetwork, StellarProtocolOptions, StellarSigner, StellarUnits } from './types/protocol';
 import { StellarSignedTransaction, StellarUnsignedTransaction } from './types/transaction';
 export { StellarModule };
-export { StellarProtocol, createStellarProtocol, createStellarProtocolOptions };
+export { StellarProtocol, createStellarProtocol, createStellarProtocolOptions, createStellarAssetProtocol, StellarAssetProtocol };
 export { StellarBlockExplorer };
-export { StellarCryptoConfiguration, StellarUnits, StellarProtocolOptions, StellarProtocolNetwork, StellarUnsignedTransaction, StellarSignedTransaction };
+export { StellarCryptoConfiguration, StellarUnits, StellarProtocolOptions, StellarProtocolNetwork, StellarUnsignedTransaction, StellarSignedTransaction, StellarAssetMetadata, StellarSigner };
 export { StellarTransactionSignRequest, StellarTransactionSignResponse };

package/v1/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StellarBlockExplorer = exports.createStellarProtocolOptions = exports.createStellarProtocol = exports.StellarModule = void 0;
+exports.StellarBlockExplorer = exports.createStellarAssetProtocol = exports.createStellarProtocolOptions = exports.createStellarProtocol = exports.StellarModule = void 0;
 var StellarBlockExplorer_1 = require("./block-explorer/StellarBlockExplorer");
 Object.defineProperty(exports, "StellarBlockExplorer", { enumerable: true, get: function () { return StellarBlockExplorer_1.StellarBlockExplorer; } });
 var StellarModule_1 = require("./module/StellarModule");
 Object.defineProperty(exports, "StellarModule", { enumerable: true, get: function () { return StellarModule_1.StellarModule; } });
+var StellarAsset_1 = require("./protocol/stellarAssets/StellarAsset");
+Object.defineProperty(exports, "createStellarAssetProtocol", { enumerable: true, get: function () { return StellarAsset_1.createStellarAssetProtocol; } });
 var StellarProtocol_1 = require("./protocol/StellarProtocol");
 Object.defineProperty(exports, "createStellarProtocol", { enumerable: true, get: function () { return StellarProtocol_1.createStellarProtocol; } });
 Object.defineProperty(exports, "createStellarProtocolOptions", { enumerable: true, get: function () { return StellarProtocol_1.createStellarProtocolOptions; } });

package/v1/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/v1/index.ts"],"names":[],"mappings":";;;AAAA,8EAA4E;AAmBnE,qGAnBA,2CAAoB,OAmBA;AAlB7B,wDAAsD;AAU7C,8FAVA,6BAAa,OAUA;AATtB,8DAAiH;AAavF,sGAbA,uCAAqB,OAaA;AAAE,6GAbA,8CAA4B,OAaA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/v1/index.ts"],"names":[],"mappings":";;;AAAA,8EAA4E;AAoBnE,qGApBA,2CAAoB,OAoBA;AAnB7B,wDAAsD;AAW7C,8FAXA,6BAAa,OAWA;AAVtB,sEAAwG;AAczB,2GAdtE,yCAA0B,OAcsE;AAbzG,8DAAiH;AAavF,sGAbA,uCAAqB,OAaA;AAAE,6GAbA,8CAA4B,OAaA"}

package/v1/module/StellarAssets.d.ts

@@ -0,0 +1,3 @@
+import { StellarAssetMetadata } from '../types/protocol';
+export declare const stellarAssets: Record<string, StellarAssetMetadata>;
+export declare const stellarAssetsIdentifiers: string[];

package/v1/module/StellarAssets.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stellarAssetsIdentifiers = exports.stellarAssets = void 0;
+exports.stellarAssets = {
+    'stellar-asset-usdc': {
+        assetCode: 'USDC',
+        name: 'Stellar USD Coin',
+        marketSymbol: 'usdc',
+        issuer: 'GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN',
+        decimals: 7,
+        identifier: 'stellar-asset-usdc'
+    },
+    'stellar-asset-eurc': {
+        assetCode: 'EURC',
+        name: 'Stellar Euro Coin',
+        marketSymbol: 'eurc',
+        issuer: 'GDHU6WRG4IEQXM5NZ4BMPKOXHW76MZM4Y2IEMFDVXBSDP6SJY4ITNPP2',
+        decimals: 7,
+        identifier: 'stellar-asset-eurc'
+    },
+    'stellar-asset-velo': {
+        assetCode: 'VELO',
+        name: 'Velo Token',
+        marketSymbol: 'velo',
+        issuer: 'GDM4RQUQQUVSKQA7S6EM7XBZP3FCGH4Q7CL6TABQ7B2BEJ5ERARM2M5M',
+        decimals: 7,
+        identifier: 'stellar-asset-velo'
+    },
+    'stellar-asset-shx': {
+        assetCode: 'SHX',
+        name: 'Stronghold Token',
+        marketSymbol: 'shx',
+        issuer: 'GDSTRSHXHGJ7ZIVRBXEYE5Q74XUVCUSEKEBR7UCHEUUEK72N7I7KJ6JH',
+        decimals: 7,
+        identifier: 'stellar-asset-shx'
+    },
+    'stellar-asset-aqua': {
+        assetCode: 'AQUA',
+        name: 'Aqua Token',
+        marketSymbol: 'aqua',
+        issuer: 'GBNZILSTVQZ4R7IKQDGHYGY2QXL5QOFJYQMXPKWRRM5PAV7Y4M67AQUA',
+        decimals: 7,
+        identifier: 'stellar-asset-aqua'
+    }
+};
+exports.stellarAssetsIdentifiers = Object.keys(exports.stellarAssets);
+//# sourceMappingURL=StellarAssets.js.map

package/v1/module/StellarAssets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StellarAssets.js","sourceRoot":"","sources":["../../../src/v1/module/StellarAssets.ts"],"names":[],"mappings":";;;AAEa,QAAA,aAAa,GAAyC;IACjE,oBAAoB,EAAE;QACpB,SAAS,EAAE,MAAM;QACjB,IAAI,EAAE,kBAAkB;QACxB,YAAY,EAAE,MAAM;QACpB,MAAM,EAAE,0DAA0D;QAClE,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,oBAAoB;KACjC;IACD,oBAAoB,EAAE;QACpB,SAAS,EAAE,MAAM;QACjB,IAAI,EAAE,mBAAmB;QACzB,YAAY,EAAE,MAAM;QACpB,MAAM,EAAE,0DAA0D;QAClE,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,oBAAoB;KACjC;IACD,oBAAoB,EAAE;QACpB,SAAS,EAAE,MAAM;QACjB,IAAI,EAAE,YAAY;QAClB,YAAY,EAAE,MAAM;QACpB,MAAM,EAAE,0DAA0D;QAClE,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,oBAAoB;KACjC;IACD,mBAAmB,EAAE;QACnB,SAAS,EAAE,KAAK;QAChB,IAAI,EAAE,kBAAkB;QACxB,YAAY,EAAE,KAAK;QACnB,MAAM,EAAE,0DAA0D;QAClE,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,mBAAmB;KAChC;IACD,oBAAoB,EAAE;QACpB,SAAS,EAAE,MAAM;QACjB,IAAI,EAAE,YAAY;QAClB,YAAY,EAAE,MAAM;QACpB,MAAM,EAAE,0DAA0D;QAClE,QAAQ,EAAE,CAAC;QACX,UAAU,EAAE,oBAAoB;KACjC;CACF,CAAA;AAEY,QAAA,wBAAwB,GAAa,MAAM,CAAC,IAAI,CAAC,qBAAa,CAAC,CAAA"}

package/v1/module/StellarModule.d.ts

@@ -1,17 +1,14 @@
 import { AirGapBlockExplorer, AirGapModule, AirGapOfflineProtocol, AirGapOnlineProtocol, AirGapV3SerializerCompanion, ProtocolConfiguration } from '@airgap/module-kit';
-import { MainProtocolSymbols } from '@airgap/coinlib-core';
 import { StellarProtocolNetwork } from '../types/protocol';
-declare type SupportedProtocols = MainProtocolSymbols.XLM;
 export declare class StellarModule implements AirGapModule<{
-    Protocols: SupportedProtocols;
     ProtocolNetwork: StellarProtocolNetwork;
 }> {
     private readonly networkRegistries;
-    readonly supportedProtocols: Record<SupportedProtocols, ProtocolConfiguration>;
-    createOfflineProtocol(identifier: SupportedProtocols): Promise<AirGapOfflineProtocol | undefined>;
-    createOnlineProtocol(identifier: SupportedProtocols, networkOrId?: StellarProtocolNetwork | string): Promise<AirGapOnlineProtocol | undefined>;
-    createBlockExplorer(identifier: SupportedProtocols, networkOrId?: StellarProtocolNetwork | string): Promise<AirGapBlockExplorer | undefined>;
+    readonly supportedProtocols: Record<string, ProtocolConfiguration>;
+    constructor();
+    createOfflineProtocol(identifier: string): Promise<AirGapOfflineProtocol | undefined>;
+    createOnlineProtocol(identifier: string, networkOrId?: StellarProtocolNetwork | string): Promise<AirGapOnlineProtocol | undefined>;
+    createBlockExplorer(identifier: string, networkOrId?: StellarProtocolNetwork | string): Promise<AirGapBlockExplorer | undefined>;
     createV3SerializerCompanion(): Promise<AirGapV3SerializerCompanion>;
     private createProtocol;
 }
-export {};

package/v1/module/StellarModule.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -43,14 +54,18 @@ var errors_1 = require("@airgap/coinlib-core/errors");
 var StellarBlockExplorer_1 = require("../block-explorer/StellarBlockExplorer");
 var StellarProtocol_1 = require("../protocol/StellarProtocol");
 var serializer_companion_1 = require("../serializer/v3/serializer-companion");
+var StellarAssets_1 = require("./StellarAssets");
+var StellarAsset_1 = require("../protocol/stellarAssets/StellarAsset");
 var StellarModule = /** @class */ (function () {
     function StellarModule() {
         var _a;
-        this.networkRegistries = (_a = {},
-            _a[coinlib_core_1.MainProtocolSymbols.XLM] = new module_kit_1.ModuleNetworkRegistry({
-                supportedNetworks: [StellarProtocol_1.STELLAR_MAINNET_PROTOCOL_NETWORK]
-            }),
-            _a);
+        var stellarNetworkRegistry = new module_kit_1.ModuleNetworkRegistry({
+            supportedNetworks: [StellarProtocol_1.STELLAR_MAINNET_PROTOCOL_NETWORK]
+        });
+        this.networkRegistries = __assign((_a = {}, _a[coinlib_core_1.MainProtocolSymbols.STELLAR] = stellarNetworkRegistry, _a), StellarAssets_1.stellarAssetsIdentifiers.reduce(function (obj, next) {
+            var _a;
+            return Object.assign(obj, (_a = {}, _a[next] = stellarNetworkRegistry, _a));
+        }, {}));
         this.supportedProtocols = (0, module_kit_1.createSupportedProtocols)(this.networkRegistries);
     }
     StellarModule.prototype.createOfflineProtocol = function (identifier) {
@@ -94,12 +109,14 @@ var StellarModule = /** @class */ (function () {
         });
     };
     StellarModule.prototype.createProtocol = function (identifier, network) {
-        switch (identifier) {
-            case coinlib_core_1.MainProtocolSymbols.XLM:
-                return (0, StellarProtocol_1.createStellarProtocol)({ network: network });
-            default:
-                throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.STELLAR, "Protocol ".concat(identifier, " not supported."));
+        if (identifier === coinlib_core_1.MainProtocolSymbols.STELLAR) {
+            return (0, StellarProtocol_1.createStellarProtocol)({ network: network });
+        }
+        if (StellarAssets_1.stellarAssets[identifier] !== undefined) {
+            var tokenMetadata = StellarAssets_1.stellarAssets[identifier];
+            return (0, StellarAsset_1.createStellarAssetProtocol)(tokenMetadata);
         }
+        throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.SERIALIZER, "Protocol ".concat(identifier, " not supported."));
     };
     return StellarModule;
 }());

package/v1/module/StellarModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"StellarModule.js","sourceRoot":"","sources":["../../../src/v1/module/StellarModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAW2B;AAC3B,qDAAkE;AAClE,sDAAqE;AAErE,+EAA6E;AAC7E,+DAAqG;AACrG,8EAAoF;AAKpF;IAAA;;QACmB,sBAAiB;YAChC,GAAC,kCAAmB,CAAC,GAAG,IAAG,IAAI,kCAAqB,CAAC;gBACnD,iBAAiB,EAAE,CAAC,kDAAgC,CAAC;aACtD,CAAC;gBACH;QAEe,uBAAkB,GAAsD,IAAA,qCAAwB,EAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;IA8C1I,CAAC;IA5Cc,6CAAqB,GAAlC,UAAmC,UAA8B;;;gBAC/D,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAA;;;KACvC;IAEY,4CAAoB,GAAjC,UACE,UAA8B,EAC9B,WAA6C;;;;;gBAEvC,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,OAAO,EAAE,iCAAiC,CAAC,CAAA;iBACrF;gBAED,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,CAAC,EAAA;;;KAChD;IAEY,2CAAmB,GAAhC,UACE,UAA8B,EAC9B,WAA6C;;;;;gBAEvC,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,OAAO,EAAE,uCAAuC,CAAC,CAAA;iBAC3F;gBAED,sBAAO,IAAI,2CAAoB,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAA;;;KAC1D;IAEY,mDAA2B,GAAxC;;;gBACE,sBAAO,IAAI,mDAA4B,EAAE,EAAA;;;KAC1C;IAEO,sCAAc,GAAtB,UAAuB,UAA8B,EAAE,OAAyB;QAC9E,QAAQ,UAAU,EAAE;YAClB,KAAK,kCAAmB,CAAC,GAAG;gBAC1B,OAAO,IAAA,uCAAqB,EAAC,EAAE,OAAO,SAAA,EAAE,CAAC,CAAA;YAC3C;gBACE,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,OAAO,EAAE,mBAAY,UAAU,oBAAiB,CAAC,CAAA;SAC7F;IACH,CAAC;IACH,oBAAC;AAAD,CAAC,AArDD,IAqDC;AArDY,sCAAa"}
+{"version":3,"file":"StellarModule.js","sourceRoot":"","sources":["../../../src/v1/module/StellarModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAW2B;AAC3B,qDAAkE;AAClE,sDAAqE;AAErE,+EAA6E;AAC7E,+DAAqG;AACrG,8EAAoF;AAEpF,iDAAyE;AACzE,uEAAmF;AAEnF;IAIE;;QACE,IAAM,sBAAsB,GAAkD,IAAI,kCAAqB,CAAC;YACtG,iBAAiB,EAAE,CAAC,kDAAgC,CAAC;SACtD,CAAC,CAAA;QAEF,IAAI,CAAC,iBAAiB,yBACnB,kCAAmB,CAAC,OAAO,IAAG,sBAAsB,OAClD,wCAAwB,CAAC,MAAM,CAChC,UAAC,GAA0C,EAAE,IAAY;;YAAK,OAAA,MAAM,CAAC,MAAM,CAAC,GAAG,YAAI,GAAC,IAAI,IAAG,sBAAsB,MAAG;QAAtD,CAAsD,EACpH,EAAE,CACH,CACF,CAAA;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAA,qCAAwB,EAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;IAC5E,CAAC;IAEY,6CAAqB,GAAlC,UAAmC,UAAkB;;;gBACnD,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAA;;;KACvC;IAEY,4CAAoB,GAAjC,UACE,UAAkB,EAClB,WAA6C;;;;;gBAEvC,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,OAAO,EAAE,iCAAiC,CAAC,CAAA;iBACrF;gBAED,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,CAAC,EAAA;;;KAChD;IAEY,2CAAmB,GAAhC,UACE,UAAkB,EAClB,WAA6C;;;;;gBAEvC,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,OAAO,EAAE,uCAAuC,CAAC,CAAA;iBAC3F;gBAED,sBAAO,IAAI,2CAAoB,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAA;;;KAC1D;IAEY,mDAA2B,GAAxC;;;gBACE,sBAAO,IAAI,mDAA4B,EAAE,EAAA;;;KAC1C;IAEO,sCAAc,GAAtB,UAAuB,UAAkB,EAAE,OAAyB;QAClE,IAAI,UAAU,KAAK,kCAAmB,CAAC,OAAO,EAAE;YAC9C,OAAO,IAAA,uCAAqB,EAAC,EAAE,OAAO,SAAA,EAAE,CAAC,CAAA;SAC1C;QAED,IAAI,6BAAa,CAAC,UAAU,CAAC,KAAK,SAAS,EAAE;YAC3C,IAAM,aAAa,GAAyB,6BAAa,CAAC,UAAU,CAAC,CAAA;YAErE,OAAO,IAAA,yCAA0B,EAAC,aAAa,CAAC,CAAA;SACjD;QAED,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,UAAU,EAAE,mBAAY,UAAU,oBAAiB,CAAC,CAAA;IAC/F,CAAC;IACH,oBAAC;AAAD,CAAC,AArED,IAqEC;AArEY,sCAAa"}

package/v1/protocol/StellarProtocol.d.ts

@@ -1,6 +1,7 @@
-import { Address, AirGapProtocol, AirGapTransaction, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, RecursivePartial, SecretKey, TransactionFullConfiguration, TransactionDetails, AirGapTransactionsWithCursor, Amount, TransactionSimpleConfiguration } from '@airgap/module-kit';
+import { Address, AirGapProtocol, AirGapTransaction, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, RecursivePartial, SecretKey, TransactionFullConfiguration, TransactionDetails, AirGapTransactionsWithCursor, Amount, TransactionSimpleConfiguration, WalletConnectRequest } from '@airgap/module-kit';
+import { Transaction, Horizon } from '@stellar/stellar-sdk';
 import { StellarCryptoConfiguration } from '../types/crypto';
-import { StellarProtocolNetwork, StellarProtocolOptions, StellarUnits } from '../types/protocol';
+import { StellarProtocolNetwork, StellarProtocolOptions, StellarSigner, StellarThresholds, StellarUnits } from '../types/protocol';
 import { StellarSignedTransaction, StellarTransactionCursor, StellarUnsignedTransaction } from '../types/transaction';
 export interface StellarProtocol extends AirGapProtocol<{
     AddressResult: Address;
@@ -11,11 +12,30 @@ export interface StellarProtocol extends AirGapProtocol<{
     Units: StellarUnits;
     FeeEstimation: FeeDefaults<StellarUnits>;
     UnsignedTransaction: StellarUnsignedTransaction;
-}, 'FetchDataForAddress'> {
+}, 'FetchDataForAddress', 'WalletConnect', 'Multisig'> {
+    server: Horizon.Server;
+    options: StellarProtocolOptions;
+    getDetailsFromEncodedGenericTransaction(transaction: string): Promise<Transaction>;
+    getSigners(publicKey: PublicKey): Promise<StellarSigner[]>;
+    adjustSigner(masterPublicky: PublicKey, signerPublicKey: PublicKey, weight: number, lowThreshold: number, medThreshold: number, highThreshold: number): Promise<StellarUnsignedTransaction>;
+    getThresholds(publicKey: PublicKey): Promise<StellarThresholds>;
+    getThresholdReachedStatus(transaction: string): Promise<{
+        thresholdRequired: number;
+        currentThreshold: number;
+    }>;
 }
 export declare class StellarProtocolImpl implements StellarProtocol {
-    private readonly options;
+    readonly options: StellarProtocolOptions;
+    readonly server: Horizon.Server;
     constructor(options?: RecursivePartial<StellarProtocolOptions>);
+    getMultisigStatus(publicKey: PublicKey): Promise<boolean>;
+    getSigners(publicKey: PublicKey): Promise<StellarSigner[]>;
+    getThresholds(publicKey: PublicKey): Promise<StellarThresholds>;
+    getThresholdReachedStatus(transaction: string): Promise<{
+        thresholdRequired: number;
+        currentThreshold: number;
+    }>;
+    adjustSigner(masterPublicky: PublicKey, signerPublicKey: PublicKey, weight: number, lowThreshold: number, medThreshold: number, highThreshold: number): Promise<StellarUnsignedTransaction>;
     getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: StellarTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<StellarTransactionCursor, StellarUnits>>;
     getTransactionsForAddress(address: Address, limit: number, cursor?: StellarTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<StellarTransactionCursor, StellarUnits>>;
     getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: Address[], configuration?: TransactionFullConfiguration<StellarUnits>): Promise<Amount<StellarUnits>>;
@@ -26,6 +46,7 @@ export declare class StellarProtocolImpl implements StellarProtocol {
     getMetadata(): Promise<ProtocolMetadata<StellarUnits>>;
     getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
     getDetailsFromTransaction(transaction: StellarSignedTransaction | StellarUnsignedTransaction, _publicKey: PublicKey): Promise<AirGapTransaction<StellarUnits>[]>;
+    getDetailsFromEncodedGenericTransaction(transaction: string): Promise<Transaction>;
     private getDetailsFromEncodedTransaction;
     private readonly cryptoConfiguration;
     getCryptoConfiguration(): Promise<StellarCryptoConfiguration>;
@@ -36,6 +57,8 @@ export declare class StellarProtocolImpl implements StellarProtocol {
     getBalanceOfAddress(address: string): Promise<Balance<StellarUnits>>;
     prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<StellarUnits>[], configuration?: TransactionFullConfiguration<StellarUnits>): Promise<StellarUnsignedTransaction>;
     broadcastTransaction(transaction: StellarSignedTransaction): Promise<string>;
+    getWalletConnectChain(): Promise<string>;
+    prepareWalletConnectTransactionWithPublicKey(publicKey: PublicKey, request: WalletConnectRequest): Promise<StellarUnsignedTransaction>;
 }
 export declare function createStellarProtocol(options?: RecursivePartial<StellarProtocolOptions>): StellarProtocol;
 export declare const STELLAR_MAINNET_PROTOCOL_NETWORK: StellarProtocolNetwork;