@ukeyfe/hardware-core 1.1.13

package/dist/api/polkadot/networks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/api/polkadot/networks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,aAAK,QAAQ;IACX,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB;AA+BD,eAAe,QAAQ,CAAC;AAExB,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,uBAEtD;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,MAAM,EAAE;;;;;;;EAQnE"}

package/dist/api/scdo/ScdoGetAddress.d.ts

@@ -0,0 +1,14 @@
+import { ScdoGetAddress as HardwareScdoGetAddress } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { ScdoAddress } from '../../types';
+export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]> {
+    hasBundle: boolean;
+    init(): void;
+    getVersionRange(): {
+        model_touch: {
+            min: string;
+        };
+    };
+    run(): Promise<ScdoAddress | ScdoAddress[]>;
+}
+//# sourceMappingURL=ScdoGetAddress.d.ts.map

package/dist/api/scdo/ScdoGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScdoGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/scdo/ScdoGetAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGtF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAwB,MAAM,aAAa,CAAC;AAEhE,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,sBAAsB,EAAE,CAAC;IAC9E,SAAS,UAAS;IAElB,IAAI;IA6BJ,eAAe;;;;;IAQT,GAAG;CA2BV"}

package/dist/api/scdo/ScdoSignMessage.d.ts

@@ -0,0 +1,12 @@
+import { ScdoSignMessage as HardwareScdoSignMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage> {
+    init(): void;
+    getVersionRange(): {
+        model_touch: {
+            min: string;
+        };
+    };
+    run(): Promise<import("@ukeyfe/hardware-transport").ScdoSignedMessage>;
+}
+//# sourceMappingURL=ScdoSignMessage.d.ts.map

package/dist/api/scdo/ScdoSignMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScdoSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/scdo/ScdoSignMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAGxF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,uBAAuB,CAAC;IAC9E,IAAI;IAoBJ,eAAe;;;;;IAQT,GAAG;CAOV"}

package/dist/api/scdo/ScdoSignTransaction.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ScdoSignTx as HardwareScdoSignTx, TypedCall, ScdoSignedTx } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+export default class ScdoSignTransaction extends BaseMethod<HardwareScdoSignTx> {
+    init(): void;
+    getVersionRange(): {
+        model_touch: {
+            min: string;
+        };
+    };
+    chunkByteSize: number;
+    processTxRequest: (typedCall: TypedCall, res: TypedResponseMessage<'ScdoSignedTx'>, data: Buffer, offset?: number) => Promise<ScdoSignedTx>;
+    run(): Promise<ScdoSignedTx>;
+}
+//# sourceMappingURL=ScdoSignTransaction.d.ts.map

package/dist/api/scdo/ScdoSignTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScdoSignTransaction.d.ts","sourceRoot":"","sources":["../../../src/api/scdo/ScdoSignTransaction.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAIvG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAGxE,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU,CAAC,kBAAkB,CAAC;IAC7E,IAAI;IAmCJ,eAAe;;;;;IAQf,aAAa,SAAQ;IAErB,gBAAgB,cACH,SAAS,OACf,qBAAqB,cAAc,CAAC,QACnC,MAAM,sBAEX,QAAQ,YAAY,CAAC,CAmBtB;IAEI,GAAG;CAiBV"}

package/dist/api/solana/SolGetAddress.d.ts

@@ -0,0 +1,9 @@
+import { SolanaGetAddress } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { SolanaAddress } from '../../types';
+export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<SolanaAddress | SolanaAddress[]>;
+}
+//# sourceMappingURL=SolGetAddress.d.ts.map

package/dist/api/solana/SolGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/solana/SolGetAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,aAAa,EAA0B,MAAM,aAAa,CAAC;AAEpE,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAC,gBAAgB,EAAE,CAAC;IACvE,SAAS,UAAS;IAElB,IAAI;IA6BE,GAAG;CA2BV"}

package/dist/api/solana/SolSignMessage.d.ts

@@ -0,0 +1,24 @@
+import { SolanaSignUnsafeMessage as HardwareSolSignUnsafeMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class SolSignMessage extends BaseMethod<HardwareSolSignUnsafeMessage> {
+    init(): void;
+    getVersionRange(): {
+        pro: {
+            min: string;
+        };
+        touch: {
+            min: string;
+        };
+        model_classic1s: {
+            min: string;
+        };
+        model_mini: {
+            min: string;
+        };
+    };
+    run(): Promise<{
+        signature: string;
+        pub: string | undefined;
+    }>;
+}
+//# sourceMappingURL=SolSignMessage.d.ts.map

package/dist/api/solana/SolSignMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/solana/SolSignMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,IAAI,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAGrG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,4BAA4B,CAAC;IAClF,IAAI;IAoBJ,eAAe;;;;;;;;;;;;;;IAiBT,GAAG;;;;CAcV"}

package/dist/api/solana/SolSignOffchainMessage.d.ts

@@ -0,0 +1,18 @@
+import { SolanaSignOffChainMessage as HardwareSolSignOffChainMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOffChainMessage> {
+    init(): void;
+    getVersionRange(): {
+        pro: {
+            min: string;
+        };
+        model_classic1s: {
+            min: string;
+        };
+    };
+    run(): Promise<{
+        signature: string;
+        pub: string | undefined;
+    }>;
+}
+//# sourceMappingURL=SolSignOffchainMessage.d.ts.map

package/dist/api/solana/SolSignOffchainMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolSignOffchainMessage.d.ts","sourceRoot":"","sources":["../../../src/api/solana/SolSignOffchainMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,IAAI,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAGzG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU,CAAC,8BAA8B,CAAC;IAC5F,IAAI;IA0BJ,eAAe;;;;;;;;IAWT,GAAG;;;;CAcV"}

package/dist/api/solana/SolSignTransaction.d.ts

@@ -0,0 +1,30 @@
+import { SolanaSignTx as HardwareSolanaSignTx } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { SolanaSignedTx } from '../../types';
+export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[]> {
+    hasBundle: boolean;
+    init(): void;
+    getVersionRange(): {
+        model_mini: {
+            min: string;
+        };
+        model_touch: {
+            min: string;
+        };
+        classic?: undefined;
+        mini?: undefined;
+    } | {
+        classic: {
+            min: string;
+        };
+        mini: {
+            min: string;
+        };
+        model_mini?: undefined;
+        model_touch?: undefined;
+    };
+    isVersionedTx(hexString: string): boolean;
+    existsVersionedTx(): boolean;
+    run(): Promise<SolanaSignedTx | SolanaSignedTx[]>;
+}
+//# sourceMappingURL=SolSignTransaction.d.ts.map

package/dist/api/solana/SolSignTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolSignTransaction.d.ts","sourceRoot":"","sources":["../../../src/api/solana/SolSignTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,cAAc,EAA+B,MAAM,aAAa,CAAC;AAG1E,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,UAAU,CAAC,oBAAoB,EAAE,CAAC;IAChF,SAAS,UAAS;IAElB,IAAI;IA2BJ,eAAe;;;;;;;;;;;;;;;;;;;IAsBf,aAAa,CAAC,SAAS,EAAE,MAAM;IAa/B,iBAAiB;IAWX,GAAG;CAoBV"}

package/dist/api/starcoin/StarcoinGetAddress.d.ts

@@ -0,0 +1,9 @@
+import { StarcoinGetAddress as HardwareStarcoinGetAddress } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { StarcoinAddress } from '../../types/api/starcoinGetAddress';
+export default class StarcoinGetAddress extends BaseMethod<HardwareStarcoinGetAddress[]> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<StarcoinAddress | StarcoinAddress[]>;
+}
+//# sourceMappingURL=StarcoinGetAddress.d.ts.map

package/dist/api/starcoin/StarcoinGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarcoinGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/starcoin/StarcoinGetAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,IAAI,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAG9F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAA4B,MAAM,oCAAoC,CAAC;AAE/F,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,UAAU,CAAC,0BAA0B,EAAE,CAAC;IACtF,SAAS,UAAS;IAElB,IAAI;IA6BE,GAAG;CA4BV"}

package/dist/api/starcoin/StarcoinGetPublicKey.d.ts

@@ -0,0 +1,9 @@
+import { StarcoinGetPublicKey as HardwareStarcoinGetPublicKey } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { StarcoinPublicKey } from '../../types/api/starcoinGetPublicKey';
+export default class StarcoinGetPublicKey extends BaseMethod<HardwareStarcoinGetPublicKey[]> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<StarcoinPublicKey | StarcoinPublicKey[]>;
+}
+//# sourceMappingURL=StarcoinGetPublicKey.d.ts.map

package/dist/api/starcoin/StarcoinGetPublicKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarcoinGetPublicKey.d.ts","sourceRoot":"","sources":["../../../src/api/starcoin/StarcoinGetPublicKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,IAAI,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAGlG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EACL,iBAAiB,EAElB,MAAM,sCAAsC,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,UAAU,CAAC,4BAA4B,EAAE,CAAC;IAC1F,SAAS,UAAS;IAElB,IAAI;IA6BE,GAAG;CA0BV"}

package/dist/api/starcoin/StarcoinSignMessage.d.ts

@@ -0,0 +1,7 @@
+import { StarcoinSignMessage as HardwareStarcoinSignMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class StarcoinSignMessage extends BaseMethod<HardwareStarcoinSignMessage> {
+    init(): void;
+    run(): Promise<import("@ukeyfe/hardware-transport").StarcoinMessageSignature>;
+}
+//# sourceMappingURL=StarcoinSignMessage.d.ts.map

package/dist/api/starcoin/StarcoinSignMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarcoinSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/starcoin/StarcoinSignMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAGhG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU,CAAC,2BAA2B,CAAC;IACtF,IAAI;IAqBE,GAAG;CAWV"}

package/dist/api/starcoin/StarcoinSignTransaction.d.ts

@@ -0,0 +1,7 @@
+import { StarcoinSignTx } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class StarcoinSignTransaction extends BaseMethod<StarcoinSignTx> {
+    init(): void;
+    run(): Promise<import("@ukeyfe/hardware-transport").StarcoinSignedTx>;
+}
+//# sourceMappingURL=StarcoinSignTransaction.d.ts.map

package/dist/api/starcoin/StarcoinSignTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarcoinSignTransaction.d.ts","sourceRoot":"","sources":["../../../src/api/starcoin/StarcoinSignTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU,CAAC,cAAc,CAAC;IAC7E,IAAI;IAqBE,GAAG;CAOV"}

package/dist/api/starcoin/StarcoinVerifyMessage.d.ts

@@ -0,0 +1,7 @@
+import { StarcoinVerifyMessage as HardwareStarcoinVerifyMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class EVMSignMessage extends BaseMethod<HardwareStarcoinVerifyMessage> {
+    init(): void;
+    run(): Promise<import("@ukeyfe/hardware-transport").Success>;
+}
+//# sourceMappingURL=StarcoinVerifyMessage.d.ts.map

package/dist/api/starcoin/StarcoinVerifyMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarcoinVerifyMessage.d.ts","sourceRoot":"","sources":["../../../src/api/starcoin/StarcoinVerifyMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,IAAI,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEpG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,6BAA6B,CAAC;IACnF,IAAI;IAmBE,GAAG;CAOV"}

package/dist/api/stellar/StellarGetAddress.d.ts

@@ -0,0 +1,9 @@
+import { StellarGetAddress as HardwareStellarGetAddress } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { StellarAddress } from '../../types';
+export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<StellarAddress | StellarAddress[]>;
+}
+//# sourceMappingURL=StellarGetAddress.d.ts.map

package/dist/api/stellar/StellarGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StellarGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/stellar/StellarGetAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,IAAI,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAG5F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAA2B,cAAc,EAAE,MAAM,aAAa,CAAC;AAEtE,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,UAAU,CAAC,yBAAyB,EAAE,CAAC;IACpF,SAAS,UAAS;IAElB,IAAI;IA6BE,GAAG;CA2BV"}

package/dist/api/stellar/StellarSignTransaction.d.ts

@@ -0,0 +1,335 @@
+/// <reference types="node" />
+import { StellarSignedTx, StellarSignTx as HardwareStellarSignTx } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { StellarOperation } from '../../types';
+export default class StellarSignTransaction extends BaseMethod<HardwareStellarSignTx> {
+    operations: any[];
+    parseOperation: (op: StellarOperation) => {
+        type: string;
+        source_account: string | undefined;
+        new_account: string;
+        starting_balance: string;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        destination_account: string;
+        asset: import("../../types").StellarAsset | undefined;
+        amount: string;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        send_asset: import("../../types").StellarAsset;
+        send_max: string;
+        destination_account: string;
+        destination_asset: import("../../types").StellarAsset;
+        destination_amount: string;
+        paths: import("../../types").StellarAsset[] | undefined;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        buying_asset: import("../../types").StellarAsset;
+        selling_asset: import("../../types").StellarAsset;
+        amount: string;
+        price_n: number;
+        price_d: number;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        buying_asset: import("../../types").StellarAsset;
+        selling_asset: import("../../types").StellarAsset;
+        amount: string;
+        offer_id: string | undefined;
+        price_n: number;
+        price_d: number;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        signer_type?: 0 | 1 | 2 | undefined;
+        signer_key?: string | Buffer | undefined;
+        signer_weight?: number | undefined;
+        type: string;
+        source_account: string | undefined;
+        clear_flags: number | undefined;
+        set_flags: number | undefined;
+        master_weight: string | number | undefined;
+        low_threshold: string | number | undefined;
+        medium_threshold: string | number | undefined;
+        high_threshold: string | number | undefined;
+        home_domain: string | undefined;
+        inflation_destination_account: string | undefined;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        asset: import("../../types").StellarAsset;
+        limit: string | undefined;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        trusted_account: string;
+        asset_type: number;
+        asset_code: string;
+        is_authorized: number;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        destination_account: string;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        key: string;
+        value: string | Buffer | undefined;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        bump_to?: undefined;
+    } | {
+        type: string;
+        source_account: string | undefined;
+        bump_to: string;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+    } | {
+        type?: undefined;
+        source_account?: undefined;
+        new_account?: undefined;
+        starting_balance?: undefined;
+        destination_account?: undefined;
+        asset?: undefined;
+        amount?: undefined;
+        send_asset?: undefined;
+        send_max?: undefined;
+        destination_asset?: undefined;
+        destination_amount?: undefined;
+        paths?: undefined;
+        buying_asset?: undefined;
+        selling_asset?: undefined;
+        price_n?: undefined;
+        price_d?: undefined;
+        offer_id?: undefined;
+        limit?: undefined;
+        trusted_account?: undefined;
+        asset_type?: undefined;
+        asset_code?: undefined;
+        is_authorized?: undefined;
+        key?: undefined;
+        value?: undefined;
+        bump_to?: undefined;
+    };
+    init(): void;
+    processTxRequest: (operations: any, index: number) => Promise<StellarSignedTx>;
+    run(): Promise<StellarSignedTx>;
+}
+//# sourceMappingURL=StellarSignTransaction.d.ts.map

package/dist/api/stellar/StellarSignTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StellarSignTransaction.d.ts","sourceRoot":"","sources":["../../../src/api/stellar/StellarSignTransaction.ts"],"names":[],"mappings":";AAAA,OAAO,EAEL,eAAe,EACf,aAAa,IAAI,qBAAqB,EACvC,MAAM,4BAA4B,CAAC;AAIpC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAgC,MAAM,aAAa,CAAC;AAE7E,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU,CAAC,qBAAqB,CAAC;IACnF,UAAU,EAAE,GAAG,EAAE,CAAM;IAEvB,cAAc,OAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoIpC;IAEF,IAAI;IAiDJ,gBAAgB,eAAsB,GAAG,SAAS,MAAM,KAAG,QAAQ,eAAe,CAAC,CAYjF;IAEI,GAAG;CAKV"}

package/dist/api/sui/SuiGetAddress.d.ts

@@ -0,0 +1,18 @@
+import { SuiGetAddress as HardwareSuiGetAddress } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { SuiAddress } from '../../types';
+export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
+    hasBundle: boolean;
+    shouldConfirm: boolean;
+    init(): void;
+    getVersionRange(): {
+        model_mini: {
+            min: string;
+        };
+        model_touch: {
+            min: string;
+        };
+    };
+    run(): Promise<SuiAddress | SuiAddress[]>;
+}
+//# sourceMappingURL=SuiGetAddress.d.ts.map

package/dist/api/sui/SuiGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/sui/SuiGetAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAIpF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAC;AAK9D,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAC,qBAAqB,EAAE,CAAC;IAC5E,SAAS,UAAS;IAElB,aAAa,UAAS;IAEtB,IAAI;IAiCJ,eAAe;;;;;;;;IAWT,GAAG;CAwDV"}

package/dist/api/sui/SuiGetPublicKey.d.ts

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+import { SuiPublicKey } from '../../types';
+export default class SuiGetPublicKey extends BaseMethod<any> {
+    hasBundle: boolean;
+    init(): void;
+    getVersionRange(): {
+        model_mini: {
+            min: string;
+        };
+        model_touch: {
+            min: string;
+        };
+    };
+    run(): Promise<SuiPublicKey | SuiPublicKey[]>;
+}
+//# sourceMappingURL=SuiGetPublicKey.d.ts.map

package/dist/api/sui/SuiGetPublicKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiGetPublicKey.d.ts","sourceRoot":"","sources":["../../../src/api/sui/SuiGetPublicKey.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAuB,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhE,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,GAAG,CAAC;IAC1D,SAAS,UAAS;IAElB,IAAI;IA6BJ,eAAe;;;;;;;;IAWT,GAAG;CAcV"}

package/dist/api/sui/SuiSignMessage.d.ts

@@ -0,0 +1,15 @@
+import { SuiSignMessage as HardwareSuiSignMessage } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+export default class SuiSignMessage extends BaseMethod<HardwareSuiSignMessage> {
+    init(): void;
+    getVersionRange(): {
+        model_mini: {
+            min: string;
+        };
+        model_touch: {
+            min: string;
+        };
+    };
+    run(): Promise<import("@ukeyfe/hardware-transport").SuiMessageSignature>;
+}
+//# sourceMappingURL=SuiSignMessage.d.ts.map

package/dist/api/sui/SuiSignMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/sui/SuiSignMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGtF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,sBAAsB,CAAC;IAC5E,IAAI;IAoBJ,eAAe;;;;;;;;IAWT,GAAG;CAOV"}