@airgap/icp 0.13.15-beta.1 → 0.13.15-beta.3

package/v1/protocol/ICPImplementation.js

@@ -1,15 +1,4 @@
 "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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -42,94 +31,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.broadcastTransaction = exports.getBalanceFromAddress = exports.decodeArguments = exports.getInfoFromSignedTransaction = exports.signTransaction = exports.signICPTransaction = exports.getInfoFromUnsignedTransaction = exports.createUnsignedTransaction = exports.getAddressFromPrincipal = exports.getAddressFromPublicKey = exports.getPrincipalFromPublicKey = exports.getKeyPairFromExtendedSecretKey = exports.createHttpAgent = void 0;
-var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-var hex_1 = require("@airgap/coinlib-core/utils/hex");
+exports.getInfoFromUnsignedStake = exports.claimOrRefreshNeuronFromAccount = exports.getNeuronInfoBySubAccount = exports.getNeuronInfo = exports.listKnownNeurons = exports.signClaimOrRefreshNeuronFromAccount = exports.signListNeurons = exports.createManageNeuronUnsignedTransaction = exports.createClaimOrRefreshNeuronFromAccountUnsignedTransaction = exports.createStakeUnsignedTransactions = exports.getFixedSubaccountFromPublicKey = exports.broadcastTransaction = exports.base64ToBytes = exports.getBalanceFromAddress = exports.decodeArguments = exports.getDetailsFromSignedTransactionTransfer = exports.signTransaction = exports.signTransactionTransfer = exports.getDetailsFromUnsignedTransactionTransfer = exports.getInfoFromUnsignedTransaction = exports.createUnsignedTransaction = exports.getAddressFromPrincipal = exports.getAddressFromPublicKey = exports.getPrincipalFromPublicKey = exports.getKeyPairFromExtendedSecretKey = exports.createHttpAgent = void 0;
+const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+const hex_1 = require("@airgap/coinlib-core/utils/hex");
+const module_kit_1 = require("@airgap/module-kit");
 require("isomorphic-fetch");
-var js_sha256_1 = require("js-sha256");
-var ledger_1 = require("../types/ledger");
-var account_1 = require("../utils/account");
-// import { requestIdOf } from '../utils/auth'
-var actor_1 = require("../utils/actor");
-var auth_1 = require("../utils/auth");
-var Cbor = __importStar(require("../utils/cbor"));
-var convert_1 = require("../utils/convert");
-var hdkey_1 = __importDefault(require("../utils/hdkey"));
-var http_1 = require("../utils/http");
-var IDL = __importStar(require("../utils/idl"));
-var principal_1 = require("../utils/principal");
-var secp256k1_1 = __importDefault(require("../utils/secp256k1"));
+const js_sha256_1 = require("js-sha256");
+const governance_1 = require("../types/governance");
+const ledger_1 = require("../types/ledger");
+const account_1 = require("../utils/account");
+const actor_1 = require("../utils/actor");
+const auth_1 = require("../utils/auth");
+const Cbor = __importStar(require("../utils/cbor"));
+const convert_1 = require("../utils/convert");
+const hdkey_1 = __importDefault(require("../utils/hdkey"));
+const http_1 = require("../utils/http");
+const IDL = __importStar(require("../utils/idl"));
+const principal_1 = require("../utils/principal");
+const secp256k1_1 = __importDefault(require("../utils/secp256k1"));
 // Agent
-function createHttpAgent(rpcUrl, identity) {
-    if (identity === void 0) { identity = new auth_1.AnonymousIdentity(); }
+function createHttpAgent(rpcUrl, identity = new auth_1.AnonymousIdentity()) {
     return new http_1.HttpAgent({
-        identity: identity,
+        identity,
         host: rpcUrl
     });
 }
 exports.createHttpAgent = createHttpAgent;
 // MNEMONIC -> KEY PAIR
 function getKeyPairFromExtendedSecretKey(extendedSecretKey) {
-    var hdKey = hdkey_1.default.fromExtendedKey(extendedSecretKey);
-    var identity = secp256k1_1.default.fromSecretKey(hdKey.privateKey);
-    var publicKey = new Uint8Array(identity.getPublicKey().toDer());
-    var privateKey = new Uint8Array(identity.getKeyPair().secretKey);
+    const hdKey = hdkey_1.default.fromExtendedKey(extendedSecretKey);
+    const identity = secp256k1_1.default.fromSecretKey(hdKey.privateKey);
+    const publicKey = new Uint8Array(identity.getPublicKey().toDer());
+    const privateKey = new Uint8Array(identity.getKeyPair().secretKey);
     return {
         publicKey: (0, convert_1.uint8ArrayToHexString)(publicKey),
         privateKey: (0, convert_1.uint8ArrayToHexString)(privateKey)
@@ -143,55 +80,55 @@ function getPrincipalFromPublicKey(publicKey) {
 exports.getPrincipalFromPublicKey = getPrincipalFromPublicKey;
 function getAddressFromPublicKey(publicKey, subAccount) {
     // Get principal from public key
-    var principal = getPrincipalFromPublicKey(publicKey);
+    const principal = getPrincipalFromPublicKey(publicKey);
     return getAddressFromPrincipal(principal, subAccount);
 }
 exports.getAddressFromPublicKey = getAddressFromPublicKey;
 function getAddressFromPrincipal(principalOrText, subAccountOrUndefined) {
-    var principal = typeof principalOrText === 'string'
+    const principal = typeof principalOrText === 'string'
         ? (0, hex_1.isHex)(principalOrText)
             ? principal_1.Principal.fromHex(principalOrText)
             : principal_1.Principal.from(principalOrText)
         : principalOrText;
-    var subAccount = typeof subAccountOrUndefined === 'string'
+    const subAccount = typeof subAccountOrUndefined === 'string'
         ? Buffer.from(subAccountOrUndefined, 'hex')
         : typeof subAccountOrUndefined === 'undefined' || subAccountOrUndefined.length === 0
             ? Buffer.alloc(32, 0)
             : subAccountOrUndefined;
     // Hash (sha224) the principal, the subAccount and some padding
-    var padding = (0, convert_1.asciiStringToByteArray)('\x0Aaccount-id');
-    var shaObj = js_sha256_1.sha224.create();
-    shaObj.update(__spreadArray(__spreadArray(__spreadArray([], __read(padding), false), __read(principal.toUint8Array()), false), __read(subAccount), false));
-    var hash = new Uint8Array(shaObj.array());
+    const padding = (0, convert_1.asciiStringToByteArray)('\x0Aaccount-id');
+    const shaObj = js_sha256_1.sha224.create();
+    shaObj.update([...padding, ...principal.toUint8Array(), ...subAccount]);
+    const hash = new Uint8Array(shaObj.array());
     // Prepend the checksum of the hash and convert to a hex string
-    var checksum = (0, convert_1.calculateCrc32)(hash);
-    var bytes = new Uint8Array(__spreadArray(__spreadArray([], __read(checksum), false), __read(hash), false));
+    const checksum = (0, convert_1.calculateCrc32)(hash);
+    const bytes = new Uint8Array([...checksum, ...hash]);
     return (0, convert_1.uint8ArrayToHexString)(bytes);
 }
 exports.getAddressFromPrincipal = getAddressFromPrincipal;
 // TRANSACTION OBJECT -> UNSIGNED TRANSACTION HEX
 function createUnsignedTransaction(transaction) {
-    var to = account_1.AccountIdentifier.fromHex(transaction.to);
+    const to = account_1.AccountIdentifier.fromHex(transaction.to);
     // Create raw request body
-    var rawRequestBody = {
+    const rawRequestBody = {
         to: to.toNumbers(),
         fee: (0, convert_1.e8sToTokens)(transaction.fee),
         amount: (0, convert_1.e8sToTokens)(transaction.amount),
         // Always explicitly set the memo for compatibility with ledger wallet - hardware wallet
-        memo: BigInt(0),
+        memo: transaction.memo || BigInt(0),
         created_at_time: [],
         from_subaccount: []
     };
     // Encode raw request
     //@ts-ignore
-    var unsignedTransaction = IDL.encode(ledger_1.TransferFn.argTypes, [rawRequestBody]);
+    const unsignedTransaction = IDL.encode(ledger_1.TransferFn.argTypes, [rawRequestBody]);
     return (0, convert_1.arrayBufferToHexString)(unsignedTransaction);
 }
 exports.createUnsignedTransaction = createUnsignedTransaction;
 // UNSIGNED TRANSACTION -> TRANSACTION DETAILS
 function getInfoFromUnsignedTransaction(unsignedTransaction) {
     //@ts-ignore
-    var transaction = IDL.decode(ledger_1.TransferFn.argTypes, Buffer.from(unsignedTransaction, 'hex'))[0];
+    const transaction = IDL.decode(ledger_1.TransferFn.argTypes, Buffer.from(unsignedTransaction, 'hex'))[0];
     return {
         to: (0, convert_1.uint8ArrayToHexString)(transaction.to),
         fee: transaction.fee.e8s,
@@ -202,175 +139,356 @@ function getInfoFromUnsignedTransaction(unsignedTransaction) {
     };
 }
 exports.getInfoFromUnsignedTransaction = getInfoFromUnsignedTransaction;
+function getDetailsFromUnsignedTransactionTransfer(unsignedTransaction, publicKey, network) {
+    const transactionDetails = getInfoFromUnsignedTransaction(unsignedTransaction);
+    return [
+        {
+            from: [getAddressFromPublicKey(publicKey)],
+            to: [transactionDetails.to],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)(transactionDetails.amount.toString(), 'blockchain'),
+            fee: (0, module_kit_1.newAmount)(transactionDetails.fee.toString(), 'blockchain'),
+            network
+        }
+    ];
+}
+exports.getDetailsFromUnsignedTransactionTransfer = getDetailsFromUnsignedTransactionTransfer;
 // UNSIGNED TRANSACTION, PRIVATE KEY -> SIGNED TRANSACTION
-function signICPTransaction(unsignedTransaction, privateKey, canisterId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var transactionDetails, Address, ICP, Memo, SubAccount, TimeStamp, TransferArgs, DEFAULT_TRANSACTION_FEE, toTransferRawRequest, rawRequestBody, args;
-        return __generator(this, function (_a) {
-            transactionDetails = getInfoFromUnsignedTransaction(unsignedTransaction);
-            Address = IDL.Vec(IDL.Nat8);
-            ICP = IDL.Record({ e8s: IDL.Nat64 });
-            Memo = IDL.Nat64;
-            SubAccount = IDL.Vec(IDL.Nat8);
-            TimeStamp = IDL.Record({ timestamp_nanos: IDL.Nat64 });
-            TransferArgs = IDL.Record({
-                to: Address,
-                fee: ICP,
-                memo: Memo,
-                from_subaccount: IDL.Opt(SubAccount),
-                created_at_time: IDL.Opt(TimeStamp),
-                amount: ICP
-            });
-            DEFAULT_TRANSACTION_FEE = BigInt(10000);
-            toTransferRawRequest = function (_a) {
-                var to = _a.to, amount = _a.amount, memo = _a.memo, fee = _a.fee, fromSubAccount = _a.fromSubAccount;
-                return {
-                    to: to.toNumbers(),
-                    fee: (0, convert_1.e8sToTokens)(fee !== null && fee !== void 0 ? fee : DEFAULT_TRANSACTION_FEE),
-                    amount: (0, convert_1.e8sToTokens)(amount),
-                    // Always explicitly set the memo for compatibility with ledger wallet - hardware wallet
-                    memo: memo !== null && memo !== void 0 ? memo : BigInt(0),
-                    created_at_time: [],
-                    from_subaccount: fromSubAccount === undefined ? [] : [fromSubAccount]
-                };
-            };
-            rawRequestBody = toTransferRawRequest(__assign(__assign({}, transactionDetails), { to: account_1.AccountIdentifier.fromHex(transactionDetails.to) }));
-            args = IDL.encode([TransferArgs], [rawRequestBody]);
-            return [2 /*return*/, signTransaction(privateKey, canisterId, args, 'transfer')];
+function signTransactionTransfer(unsignedTransaction, privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // TODO : REFACTOR
+        const transactionDetails = getInfoFromUnsignedTransaction(unsignedTransaction);
+        const Address = IDL.Vec(IDL.Nat8);
+        const ICP = IDL.Record({ e8s: IDL.Nat64 });
+        const Memo = IDL.Nat64;
+        const SubAccount = IDL.Vec(IDL.Nat8);
+        const TimeStamp = IDL.Record({ timestamp_nanos: IDL.Nat64 });
+        const TransferArgs = IDL.Record({
+            to: Address,
+            fee: ICP,
+            memo: Memo,
+            from_subaccount: IDL.Opt(SubAccount),
+            created_at_time: IDL.Opt(TimeStamp),
+            amount: ICP
         });
+        const DEFAULT_TRANSACTION_FEE = BigInt(10000);
+        const toTransferRawRequest = ({ to, amount, memo, fee, fromSubAccount }) => {
+            return {
+                to: to.toNumbers(),
+                fee: (0, convert_1.e8sToTokens)(fee !== null && fee !== void 0 ? fee : DEFAULT_TRANSACTION_FEE),
+                amount: (0, convert_1.e8sToTokens)(amount),
+                // Always explicitly set the memo for compatibility with ledger wallet - hardware wallet
+                memo: memo !== null && memo !== void 0 ? memo : BigInt(0),
+                created_at_time: [],
+                from_subaccount: fromSubAccount === undefined ? [] : [fromSubAccount]
+            };
+        };
+        const rawRequestBody = toTransferRawRequest(Object.assign(Object.assign({}, transactionDetails), { to: account_1.AccountIdentifier.fromHex(transactionDetails.to) }));
+        const args = IDL.encode([TransferArgs], [rawRequestBody]);
+        return signTransaction(privateKey, canisterId, args, 'transfer', 'call');
     });
 }
-exports.signICPTransaction = signICPTransaction;
-function signTransaction(privateKey, canisterId, arg, methodName) {
-    return __awaiter(this, void 0, void 0, function () {
-        var identity, submit, transform, request, transformedRequest, encoded;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    identity = secp256k1_1.default.fromSecretKey((0, convert_1.hexStringToArrayBuffer)(privateKey));
-                    submit = {
-                        request_type: http_1.SubmitRequestType.Call,
-                        canister_id: principal_1.Principal.from(canisterId),
-                        method_name: methodName,
-                        arg: arg,
-                        sender: identity.getPrincipal(),
-                        ingress_expiry: new http_1.Expiry(5 * 60 * 1000)
-                    };
-                    transform = function (request) { return __awaiter(_this, void 0, void 0, function () {
-                        var p;
-                        return __generator(this, function (_a) {
-                            p = Promise.resolve(request);
-                            return [2 /*return*/, p];
-                        });
-                    }); };
-                    return [4 /*yield*/, transform({
-                            request: {
-                                body: null,
-                                method: 'POST',
-                                headers: {
-                                    'Content-Type': 'application/cbor'
-                                }
-                            },
-                            endpoint: "call" /* Endpoint.Call */,
-                            body: submit
-                        })];
-                case 1:
-                    request = (_a.sent());
-                    return [4 /*yield*/, identity.transformRequest(request)];
-                case 2:
-                    transformedRequest = (_a.sent());
-                    encoded = Cbor.encode(transformedRequest.body);
-                    return [2 /*return*/, (0, convert_1.arrayBufferToHexString)(encoded)];
-            }
+exports.signTransactionTransfer = signTransactionTransfer;
+function signTransaction(privateKey, canisterId, arg, methodName, callType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const identity = secp256k1_1.default.fromSecretKey((0, convert_1.hexStringToArrayBuffer)(privateKey));
+        let submit;
+        if (callType === 'query') {
+            submit = {
+                request_type: "query" /* ReadRequestType.Query */,
+                canister_id: principal_1.Principal.from(canisterId),
+                method_name: methodName,
+                arg,
+                sender: identity.getPrincipal(),
+                ingress_expiry: new http_1.Expiry(5 * 60 * 1000)
+            };
+        }
+        else {
+            submit = {
+                request_type: http_1.SubmitRequestType.Call,
+                canister_id: principal_1.Principal.from(canisterId),
+                method_name: methodName,
+                arg,
+                sender: identity.getPrincipal(),
+                ingress_expiry: new http_1.Expiry(5 * 60 * 1000)
+            };
+        }
+        const transform = (request) => __awaiter(this, void 0, void 0, function* () {
+            let p = Promise.resolve(request);
+            return p;
         });
+        let request;
+        if (callType === 'query') {
+            request = (yield transform({
+                request: {
+                    body: null,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/cbor'
+                    }
+                },
+                endpoint: "read" /* Endpoint.Query */,
+                body: submit
+            }));
+        }
+        else {
+            request = (yield transform({
+                request: {
+                    body: null,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/cbor'
+                    }
+                },
+                endpoint: "call" /* Endpoint.Call */,
+                body: submit
+            }));
+        }
+        // Apply transform for identity.
+        const transformedRequest = (yield identity.transformRequest(request));
+        const encoded = Cbor.encode(transformedRequest.body);
+        return (0, convert_1.arrayBufferToHexString)(encoded);
     });
 }
 exports.signTransaction = signTransaction;
 // SIGNED TRANSACTION -> TRANSACTION DETAILS
-function getInfoFromSignedTransaction(signedTransaction) {
-    return Cbor.decode((0, convert_1.hexStringToArrayBuffer)(signedTransaction));
+function getDetailsFromSignedTransactionTransfer(signedTransaction, publicKey, network) {
+    const transactionInfo = Cbor.decode((0, convert_1.hexStringToArrayBuffer)(signedTransaction));
+    const args = decodeArguments(ledger_1.TransferArgs, transactionInfo.content.arg);
+    return [
+        {
+            from: [getAddressFromPublicKey(publicKey)],
+            to: [(0, convert_1.uint8ArrayToHexString)(args.to)],
+            isInbound: false,
+            amount: (0, module_kit_1.newAmount)(args.amount.e8s.toString(), 'blockchain'),
+            fee: (0, module_kit_1.newAmount)(args.fee.e8s.toString(), 'blockchain'),
+            network
+        }
+    ];
 }
-exports.getInfoFromSignedTransaction = getInfoFromSignedTransaction;
-function decodeArguments(args) {
-    var Address = IDL.Vec(IDL.Nat8);
-    var ICP = IDL.Record({ e8s: IDL.Nat64 });
-    var Memo = IDL.Nat64;
-    var SubAccount = IDL.Vec(IDL.Nat8);
-    var TimeStamp = IDL.Record({ timestamp_nanos: IDL.Nat64 });
-    var TransferArgs = IDL.Record({
-        to: Address,
-        fee: ICP,
-        memo: Memo,
-        from_subaccount: IDL.Opt(SubAccount),
-        created_at_time: IDL.Opt(TimeStamp),
-        amount: ICP
-    });
-    return IDL.decode([TransferArgs], args);
+exports.getDetailsFromSignedTransactionTransfer = getDetailsFromSignedTransactionTransfer;
+function decodeArguments(idlInterface, args) {
+    return IDL.decode([idlInterface], args)[0];
 }
 exports.decodeArguments = decodeArguments;
 // ADDRESS -> BALANCE
 function getBalanceFromAddress(address, host, canisterId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var agent, actor, acc, b;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    agent = createHttpAgent(host, secp256k1_1.default.generate());
-                    actor = actor_1.Actor.createActor(ledger_1.idlFactory, {
-                        agent: agent,
-                        canisterId: canisterId
-                    });
-                    acc = Uint8Array.from(Buffer.from(address, 'hex'));
-                    return [4 /*yield*/, actor.account_balance({
-                            account: __spreadArray([], __read(acc), false)
-                        })];
-                case 1:
-                    b = (_a.sent());
-                    return [2 /*return*/, b.e8s];
-            }
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = createHttpAgent(host, secp256k1_1.default.generate());
+        const actor = actor_1.Actor.createActor(ledger_1.idlFactory, {
+            agent,
+            canisterId
         });
+        let acc = Uint8Array.from(Buffer.from(address, 'hex'));
+        const b = (yield actor.account_balance({
+            account: [...acc]
+        }));
+        return b.e8s;
     });
 }
 exports.getBalanceFromAddress = getBalanceFromAddress;
-function broadcastTransaction(signedTransaction, host, canisterId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var canister, body, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    canister = principal_1.Principal.from(canisterId);
-                    body = (0, convert_1.hexStringToArrayBuffer)(signedTransaction);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    /*const request = */ return [4 /*yield*/, index_1.default.post('' + new URL("/api/v2/canister/".concat(canister.toText(), "/call"), host), body, {
-                            headers: {
-                                'Content-Type': 'application/cbor'
-                            }
-                        })
-                        // const submit: CallRequest = {
-                        //   ...signedTransactionInfo.content,
-                        //   ingress_expiry: new Expiry(1000)
-                        // }
-                        // await Promise.all([request, requestIdOf(submit)])
-                    ];
-                case 2:
-                    /*const request = */ _a.sent();
-                    // const submit: CallRequest = {
-                    //   ...signedTransactionInfo.content,
-                    //   ingress_expiry: new Expiry(1000)
-                    // }
-                    // await Promise.all([request, requestIdOf(submit)])
-                    return [2 /*return*/, ''];
-                case 3:
-                    error_1 = _a.sent();
-                    console.error('Error: ', error_1);
-                    return [2 /*return*/, ''];
-                case 4: return [2 /*return*/];
-            }
-        });
+function base64ToBytes(base64) {
+    const binary_string = window.atob(base64);
+    const len = binary_string.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binary_string.charCodeAt(i);
+    }
+    return bytes;
+}
+exports.base64ToBytes = base64ToBytes;
+function broadcastTransaction(signedTransaction, host, canisterId, requestType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const canister = principal_1.Principal.from(canisterId);
+        const body = (0, convert_1.hexStringToArrayBuffer)(signedTransaction);
+        // const signedTransactionInfo = getInfoFromSignedTransaction(signedTransaction)
+        try {
+            const response = yield index_1.default.post('' + new URL(`/api/v2/canister/${canister.toText()}/${requestType}`, host), body, {
+                headers: {
+                    'Content-Type': 'application/cbor'
+                }
+            });
+            const bytes = base64ToBytes(response.data);
+            const test2 = Cbor.decode(bytes);
+            console.log('test2', test2);
+            // const submit: CallRequest = {
+            //   ...signedTransactionInfo.content,
+            //   ingress_expiry: new Expiry(1000)
+            // }
+            // await Promise.all([request, requestIdOf(submit)])
+            return '';
+        }
+        catch (error) {
+            console.error('Error: ', error);
+            return '';
+        }
     });
 }
 exports.broadcastTransaction = broadcastTransaction;
+// STAKING
+function getFixedSubaccountFromPublicKey(publicKey) {
+    // Create subaccount from publicKey
+    const principal = getPrincipalFromPublicKey(publicKey);
+    const padding = (0, convert_1.asciiStringToByteArray)('neuron-stake');
+    const shaObj = js_sha256_1.sha256.create();
+    // Should be random?
+    //const nonceBytes = new Uint8Array(randomBytes(8))
+    const arr = (0, convert_1.hexStringToUint8Array)(publicKey);
+    const nonceBytes = new Uint8Array(arr.buffer, arr.byteLength - 8);
+    const nonce = (0, convert_1.uint8ArrayToBigInt)(nonceBytes);
+    shaObj.update([0x0c, ...padding, ...principal.toUint8Array(), ...nonceBytes]);
+    const toSubAccount = account_1.SubAccount.fromBytes(new Uint8Array(shaObj.array()));
+    return {
+        subAccount: toSubAccount,
+        nonce: nonce
+    };
+}
+exports.getFixedSubaccountFromPublicKey = getFixedSubaccountFromPublicKey;
+function createStakeUnsignedTransactions(amount, fee, publicKey, canisterId) {
+    const { subAccount, nonce } = getFixedSubaccountFromPublicKey(publicKey);
+    const accountIdentifier = account_1.AccountIdentifier.fromPrincipal({
+        principal: principal_1.Principal.from(canisterId),
+        subAccount: subAccount
+    });
+    // Send amount to the ledger.
+    const unsignedTransfer = createUnsignedTransaction({
+        memo: nonce,
+        amount: amount,
+        to: accountIdentifier.toHex(),
+        fee: fee
+    });
+    // Notify the governance of the transaction so that the neuron is created.
+    // const unsignedClaim = createClaimOrRefreshNeuronFromAccountUnsignedTransaction(principal, nonce)
+    return [unsignedTransfer];
+}
+exports.createStakeUnsignedTransactions = createStakeUnsignedTransactions;
+function createClaimOrRefreshNeuronFromAccountUnsignedTransaction(principal, memo) {
+    const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+        controller: IDL.Opt(IDL.Principal),
+        memo: IDL.Nat64
+    });
+    console.log('principal', principal);
+    const unsignedTransaction = IDL.encode([ClaimOrRefreshNeuronFromAccount], [{ controller: [principal], memo: memo }]);
+    return (0, convert_1.arrayBufferToHexString)(unsignedTransaction);
+}
+exports.createClaimOrRefreshNeuronFromAccountUnsignedTransaction = createClaimOrRefreshNeuronFromAccountUnsignedTransaction;
+function createManageNeuronUnsignedTransaction(principal, memo) {
+    const NeuronId = IDL.Record({ id: IDL.Nat64 });
+    const NeuronIdOrSubaccount = IDL.Variant({
+        Subaccount: IDL.Vec(IDL.Nat8),
+        NeuronId: NeuronId
+    });
+    const Follow = IDL.Record({
+        topic: IDL.Int32,
+        followees: IDL.Vec(NeuronId)
+    });
+    const Command = IDL.Variant({
+        Follow: Follow
+    });
+    const ManageNeuron = IDL.Record({
+        id: IDL.Opt(NeuronId),
+        command: IDL.Opt(Command),
+        neuron_id_or_subaccount: IDL.Opt(NeuronIdOrSubaccount)
+    });
+    console.log('principal', principal);
+    const unsignedTransaction = IDL.encode([ManageNeuron], [{ controller: [principal], memo: memo }]);
+    return (0, convert_1.arrayBufferToHexString)(unsignedTransaction);
+}
+exports.createManageNeuronUnsignedTransaction = createManageNeuronUnsignedTransaction;
+function signListNeurons(privateKey, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ListNeurons = IDL.Record({
+            neuron_ids: IDL.Vec(IDL.Nat64),
+            include_neurons_readable_by_caller: IDL.Bool
+        });
+        const args = IDL.encode([ListNeurons], [{ neuron_ids: [], include_neurons_readable_by_caller: true }]);
+        const signedTransaction = signTransaction(privateKey, canisterId, args, 'list_neurons', 'query');
+        return signedTransaction;
+    });
+}
+exports.signListNeurons = signListNeurons;
+function signClaimOrRefreshNeuronFromAccount(privateKey, principal, memo, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+            controller: IDL.Opt(IDL.Principal),
+            memo: IDL.Nat64
+        });
+        const args = IDL.encode([ClaimOrRefreshNeuronFromAccount], [{ controller: principal, memo: memo }]);
+        const signedTransaction = signTransaction(privateKey, canisterId, args, 'claim_or_refresh_neuron_from_account', 'call');
+        return signedTransaction;
+    });
+}
+exports.signClaimOrRefreshNeuronFromAccount = signClaimOrRefreshNeuronFromAccount;
+function listKnownNeurons(host, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = createHttpAgent(host, secp256k1_1.default.generate());
+        const actor = actor_1.Actor.createActor(governance_1.idlFactory, {
+            agent,
+            canisterId
+        });
+        const result = (yield actor.list_known_neurons());
+        return result.known_neurons;
+    });
+}
+exports.listKnownNeurons = listKnownNeurons;
+function getNeuronInfo(neuronId, host, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = createHttpAgent(host, secp256k1_1.default.generate());
+        const actor = actor_1.Actor.createActor(governance_1.idlFactory, {
+            agent,
+            canisterId
+        });
+        const result = (yield actor.get_neuron_info(BigInt(neuronId)));
+        if (result.Ok)
+            return result.Ok;
+        else
+            return undefined;
+    });
+}
+exports.getNeuronInfo = getNeuronInfo;
+function getNeuronInfoBySubAccount(publicKey, host, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create subaccount from publicKey
+        const { subAccount, nonce: _ } = getFixedSubaccountFromPublicKey(publicKey);
+        const agent = createHttpAgent(host, secp256k1_1.default.generate());
+        const actor = actor_1.Actor.createActor(governance_1.idlFactory, {
+            agent,
+            canisterId
+        });
+        const array = subAccount.toUint8Array();
+        console.log('subAccount', array);
+        const result = (yield actor.get_neuron_info_by_id_or_subaccount({ Subaccount: array }));
+        console.log('result', result);
+        if (result.Ok)
+            return result.Ok;
+        else
+            return undefined;
+    });
+}
+exports.getNeuronInfoBySubAccount = getNeuronInfoBySubAccount;
+function claimOrRefreshNeuronFromAccount(principal, memo, host, canisterId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = createHttpAgent(host, secp256k1_1.default.generate());
+        const actor = actor_1.Actor.createActor(governance_1.idlFactory, {
+            agent,
+            canisterId
+        });
+        const result = (yield actor.claim_or_refresh_neuron_from_account({ controller: principal, memo: memo }));
+        if (result.Ok)
+            return result.Ok;
+        else
+            return undefined;
+    });
+}
+exports.claimOrRefreshNeuronFromAccount = claimOrRefreshNeuronFromAccount;
+function getInfoFromUnsignedStake(unsignedTransaction) {
+    const ClaimOrRefreshNeuronFromAccount = IDL.Record({
+        controller: IDL.Opt(IDL.Principal),
+        memo: IDL.Nat64
+    });
+    const transaction = IDL.decode([ClaimOrRefreshNeuronFromAccount], Buffer.from(unsignedTransaction, 'hex'))[0];
+    console.log('DECODEDDDDDD', transaction);
+    return '';
+}
+exports.getInfoFromUnsignedStake = getInfoFromUnsignedStake;
 //# sourceMappingURL=ICPImplementation.js.map