@bitgo/sdk-coin-sui 5.19.2 → 5.19.4

package/dist/test/integration/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/test/integration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../test/integration/index.ts"],"names":[],"mappings":""}

package/dist/test/integration/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90ZXN0L2ludGVncmF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIiXX0=

package/dist/test/local_fullnode/RpcClient.d.ts

@@ -0,0 +1,60 @@
+import { SuiObjectData, SuiTransactionBlockResponse } from '../../src/lib/mystenlab/types';
+import { DelegatedStake } from '../../src/lib/mystenlab/types/validator';
+export declare class RpcError extends Error {
+    rpcError: {
+        code: number;
+        message: string;
+    };
+    constructor(rpcError: {
+        code: number;
+        message: string;
+    });
+    static isRpcErrorWithCode(e: Error, code: number): boolean;
+}
+export type Coin = {
+    coinType: string;
+    coinObjectId: string;
+    version: string;
+    digest: string;
+    balance: string;
+    previousTransaction: string;
+};
+/** Wrapper around https://docs.sui.io/sui-jsonrpc */
+export declare class RpcClient {
+    url: string;
+    id: number;
+    constructor(url: string);
+    static createCheckedConnection(url: string): Promise<RpcClient>;
+    exec<T>(method: string, ...params: unknown[]): Promise<T>;
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getCoins
+     */
+    getCoins(owner: string, coinType?: string, cursor?: string, limit?: number): Promise<{
+        data: Coin[];
+        nextCursor?: string;
+        hasNextPage?: boolean;
+    }>;
+    executeTransactionBlock(tx_bytes: string, signatures: string[], options?: unknown, request_type?: unknown): Promise<SuiTransactionBlockResponse>;
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getValidatorsApy
+     * APY = Annual Percentage Yield
+     */
+    getValidatorsApy(): Promise<{
+        apys: {
+            address: string;
+            apy: string;
+        }[];
+        epoch: string;
+    }>;
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getStakes
+     */
+    getStakes(owner: string): Promise<DelegatedStake[]>;
+    /**
+     * https://docs.sui.io/sui-jsonrpc#sui_getObject
+     */
+    getObject(object_id: string): Promise<{
+        data: SuiObjectData;
+    }>;
+}
+//# sourceMappingURL=RpcClient.d.ts.map

package/dist/test/local_fullnode/RpcClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcClient.d.ts","sourceRoot":"","sources":["../../../test/local_fullnode/RpcClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAqBzE,qBAAa,QAAS,SAAQ,KAAK;IAC1B,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;gBAEvC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAKvD,MAAM,CAAC,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;CAG3D;AAED,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,qDAAqD;AACrD,qBAAa,SAAS;IACb,GAAG,EAAE,MAAM,CAAC;IAEnB,EAAE,SAAK;gBAEK,GAAG,EAAE,MAAM;WAIV,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAQ/D,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;IAwB/D;;OAEG;IACG,QAAQ,CACZ,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC;QACT,IAAI,EAAE,IAAI,EAAE,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IAII,uBAAuB,CAC3B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,OAAO,EACjB,YAAY,CAAC,EAAE,OAAO,GACrB,OAAO,CAAC,2BAA2B,CAAC;IAiBvC;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC;QAChC,IAAI,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QACzC,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IAIF;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAIzD;;OAEG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;CAGrE"}

package/dist/test/local_fullnode/RpcClient.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = exports.RpcError = void 0;
+const util_1 = __importDefault(require("util"));
+const axios_1 = __importDefault(require("axios"));
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('RpcClient');
+function elideResponse(method) {
+    return method === 'sui_getProtocolConfig';
+}
+function unwrapResult(method, v) {
+    if ('error' in v) {
+        debug('< %s ERROR', method, v.error);
+        throw new Error(JSON.stringify(v.error));
+    }
+    if (elideResponse(method)) {
+        debug('< %s ...', method);
+    }
+    else {
+        debug('< %s', method, util_1.default.inspect(v.result, { depth: 10 }));
+    }
+    return v.result;
+}
+class RpcError extends Error {
+    constructor(rpcError) {
+        super(`RPC error: ${rpcError.message} (code=${rpcError.code})`);
+        this.rpcError = rpcError;
+    }
+    static isRpcErrorWithCode(e, code) {
+        return e instanceof RpcError && e.rpcError.code === code;
+    }
+}
+exports.RpcError = RpcError;
+/** Wrapper around https://docs.sui.io/sui-jsonrpc */
+class RpcClient {
+    constructor(url) {
+        // Running counter, increments every request
+        this.id = 0;
+        this.url = url;
+    }
+    static async createCheckedConnection(url) {
+        const rpcClient = new RpcClient(url);
+        const { protocolVersion } = await rpcClient.exec('sui_getProtocolConfig');
+        const chainId = await rpcClient.exec('sui_getChainIdentifier');
+        debug('Connected to', url, 'protocolVersion', protocolVersion, 'chainId', chainId);
+        return rpcClient;
+    }
+    async exec(method, ...params) {
+        params = params.filter((v) => v !== undefined);
+        try {
+            debug('>', this.url, method, params);
+            const response = await axios_1.default.post(this.url, {
+                jsonrpc: '2.0',
+                method,
+                params,
+                id: `${this.id++}`,
+            });
+            return unwrapResult(method, response.data);
+        }
+        catch (e) {
+            if (e.isAxiosError && e.response) {
+                e = e;
+                debug('< %s ERROR', method, e.response.statusText, util_1.default.inspect(e.response.data, { depth: 10 }));
+                e = e;
+                const { error = {} } = e.response.data;
+                throw new RpcError(error);
+            }
+            throw e;
+        }
+    }
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getCoins
+     */
+    async getCoins(owner, coinType, cursor, limit) {
+        return this.exec('suix_getCoins', owner, coinType, cursor, limit);
+    }
+    async executeTransactionBlock(tx_bytes, signatures, options, request_type) {
+        return this.exec('sui_executeTransactionBlock', tx_bytes, signatures, {
+            showInput: true,
+            showRawInput: true,
+            showEffects: true,
+            showEvents: true,
+            showObjectChanges: true,
+            showBalanceChanges: true,
+        }, request_type);
+    }
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getValidatorsApy
+     * APY = Annual Percentage Yield
+     */
+    async getValidatorsApy() {
+        return this.exec('suix_getValidatorsApy');
+    }
+    /**
+     * https://docs.sui.io/sui-jsonrpc#suix_getStakes
+     */
+    async getStakes(owner) {
+        return this.exec('suix_getStakes', owner);
+    }
+    /**
+     * https://docs.sui.io/sui-jsonrpc#sui_getObject
+     */
+    async getObject(object_id) {
+        return this.exec('sui_getObject', object_id, { showData: true });
+    }
+}
+exports.RpcClient = RpcClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RpcClient.js","sourceRoot":"","sources":["../../../test/local_fullnode/RpcClient.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AACxB,kDAA0C;AAC1C,kDAA+B;AAI/B,MAAM,KAAK,GAAG,IAAA,eAAU,EAAC,WAAW,CAAC,CAAC;AAEtC,SAAS,aAAa,CAAC,MAAc;IACnC,OAAO,MAAM,KAAK,uBAAuB,CAAC;AAC5C,CAAC;AAED,SAAS,YAAY,CAAI,MAAc,EAAE,CAA+D;IACtG,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;QACjB,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC5B,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,cAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,CAAC,CAAC,MAAM,CAAC;AAClB,CAAC;AAED,MAAa,QAAS,SAAQ,KAAK;IAGjC,YAAY,QAA2C;QACrD,KAAK,CAAC,cAAc,QAAQ,CAAC,OAAO,UAAU,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC;QAChE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,kBAAkB,CAAC,CAAQ,EAAE,IAAY;QAC9C,OAAO,CAAC,YAAY,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC;IAC3D,CAAC;CACF;AAXD,4BAWC;AAWD,qDAAqD;AACrD,MAAa,SAAS;IAKpB,YAAY,GAAW;QAHvB,4CAA4C;QAC5C,OAAE,GAAG,CAAC,CAAC;QAGL,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,GAAW;QAC9C,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,SAAS,CAAC,IAAI,CAA8B,uBAAuB,CAAC,CAAC;QACvG,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QAC/D,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,iBAAiB,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QACnF,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,IAAI,CAAI,MAAc,EAAE,GAAG,MAAiB;QAChD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC;YACH,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;YACrC,MAAM,QAAQ,GAAG,MAAM,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1C,OAAO,EAAE,KAAK;gBACd,MAAM;gBACN,MAAM;gBACN,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,EAAE;aACnB,CAAC,CAAC;YACH,OAAO,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC7C,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;gBACjC,CAAC,GAAG,CAAe,CAAC;gBACpB,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,UAAU,EAAE,cAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;gBACjG,CAAC,GAAG,CAAe,CAAC;gBACpB,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACvC,MAAM,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC;YAED,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,CACZ,KAAa,EACb,QAAiB,EACjB,MAAe,EACf,KAAc;QAMd,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,QAAgB,EAChB,UAAoB,EACpB,OAAiB,EACjB,YAAsB;QAEtB,OAAO,IAAI,CAAC,IAAI,CACd,6BAA6B,EAC7B,QAAQ,EACR,UAAU,EACV;YACE,SAAS,EAAE,IAAI;YACf,YAAY,EAAE,IAAI;YAClB,WAAW,EAAE,IAAI;YACjB,UAAU,EAAE,IAAI;YAChB,iBAAiB,EAAE,IAAI;YACvB,kBAAkB,EAAE,IAAI;SACzB,EACD,YAAY,CACb,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,gBAAgB;QAIpB,OAAO,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAAa;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,SAAiB;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACnE,CAAC;CACF;AAvGD,8BAuGC","sourcesContent":["import util from 'util';\nimport axios, { AxiosError } from 'axios';\nimport buildDebug from 'debug';\nimport { SuiObjectData, SuiTransactionBlockResponse } from '../../src/lib/mystenlab/types';\nimport { DelegatedStake } from '../../src/lib/mystenlab/types/validator';\n\nconst debug = buildDebug('RpcClient');\n\nfunction elideResponse(method: string): boolean {\n  return method === 'sui_getProtocolConfig';\n}\n\nfunction unwrapResult<A>(method: string, v: { result: A } | { error: { code: number; message: string } }): A {\n  if ('error' in v) {\n    debug('< %s ERROR', method, v.error);\n    throw new Error(JSON.stringify(v.error));\n  }\n  if (elideResponse(method)) {\n    debug('< %s ...', method);\n  } else {\n    debug('< %s', method, util.inspect(v.result, { depth: 10 }));\n  }\n  return v.result;\n}\n\nexport class RpcError extends Error {\n  public rpcError: { code: number; message: string };\n\n  constructor(rpcError: { code: number; message: string }) {\n    super(`RPC error: ${rpcError.message} (code=${rpcError.code})`);\n    this.rpcError = rpcError;\n  }\n\n  static isRpcErrorWithCode(e: Error, code: number): boolean {\n    return e instanceof RpcError && e.rpcError.code === code;\n  }\n}\n\nexport type Coin = {\n  coinType: string;\n  coinObjectId: string;\n  version: string;\n  digest: string;\n  balance: string;\n  previousTransaction: string;\n};\n\n/** Wrapper around https://docs.sui.io/sui-jsonrpc */\nexport class RpcClient {\n  public url: string;\n  // Running counter, increments every request\n  id = 0;\n\n  constructor(url: string) {\n    this.url = url;\n  }\n\n  static async createCheckedConnection(url: string): Promise<RpcClient> {\n    const rpcClient = new RpcClient(url);\n    const { protocolVersion } = await rpcClient.exec<{ protocolVersion: string }>('sui_getProtocolConfig');\n    const chainId = await rpcClient.exec('sui_getChainIdentifier');\n    debug('Connected to', url, 'protocolVersion', protocolVersion, 'chainId', chainId);\n    return rpcClient;\n  }\n\n  async exec<T>(method: string, ...params: unknown[]): Promise<T> {\n    params = params.filter((v) => v !== undefined);\n    try {\n      debug('>', this.url, method, params);\n      const response = await axios.post(this.url, {\n        jsonrpc: '2.0',\n        method,\n        params,\n        id: `${this.id++}`,\n      });\n      return unwrapResult(method, response.data);\n    } catch (e) {\n      if (e.isAxiosError && e.response) {\n        e = e as AxiosError;\n        debug('< %s ERROR', method, e.response.statusText, util.inspect(e.response.data, { depth: 10 }));\n        e = e as AxiosError;\n        const { error = {} } = e.response.data;\n        throw new RpcError(error);\n      }\n\n      throw e;\n    }\n  }\n\n  /**\n   * https://docs.sui.io/sui-jsonrpc#suix_getCoins\n   */\n  async getCoins(\n    owner: string,\n    coinType?: string,\n    cursor?: string,\n    limit?: number\n  ): Promise<{\n    data: Coin[];\n    nextCursor?: string;\n    hasNextPage?: boolean;\n  }> {\n    return this.exec('suix_getCoins', owner, coinType, cursor, limit);\n  }\n\n  async executeTransactionBlock(\n    tx_bytes: string,\n    signatures: string[],\n    options?: unknown,\n    request_type?: unknown\n  ): Promise<SuiTransactionBlockResponse> {\n    return this.exec(\n      'sui_executeTransactionBlock',\n      tx_bytes,\n      signatures,\n      {\n        showInput: true,\n        showRawInput: true,\n        showEffects: true,\n        showEvents: true,\n        showObjectChanges: true,\n        showBalanceChanges: true,\n      },\n      request_type\n    );\n  }\n\n  /**\n   * https://docs.sui.io/sui-jsonrpc#suix_getValidatorsApy\n   * APY = Annual Percentage Yield\n   */\n  async getValidatorsApy(): Promise<{\n    apys: { address: string; apy: string }[];\n    epoch: string;\n  }> {\n    return this.exec('suix_getValidatorsApy');\n  }\n\n  /**\n   * https://docs.sui.io/sui-jsonrpc#suix_getStakes\n   */\n  async getStakes(owner: string): Promise<DelegatedStake[]> {\n    return this.exec('suix_getStakes', owner);\n  }\n\n  /**\n   * https://docs.sui.io/sui-jsonrpc#sui_getObject\n   */\n  async getObject(object_id: string): Promise<{ data: SuiObjectData }> {\n    return this.exec('sui_getObject', object_id, { showData: true });\n  }\n}\n"]}

package/dist/test/local_fullnode/faucet.d.ts

@@ -0,0 +1,6 @@
+export declare class Faucet {
+    url: string;
+    constructor(url: string);
+    getCoins(address: string, amount: number): Promise<void>;
+}
+//# sourceMappingURL=faucet.d.ts.map

package/dist/test/local_fullnode/faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../../test/local_fullnode/faucet.ts"],"names":[],"mappings":"AAEA,qBAAa,MAAM;IACV,GAAG,EAAE,MAAM,CAAC;gBACP,GAAG,EAAE,MAAM;IAIjB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/D"}

package/dist/test/local_fullnode/faucet.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Faucet = void 0;
+const axios_1 = __importDefault(require("axios"));
+class Faucet {
+    constructor(url) {
+        this.url = url;
+    }
+    async getCoins(address, amount) {
+        await axios_1.default.post(this.url + '/gas', { FixedAmountRequest: { recipient: address } });
+    }
+}
+exports.Faucet = Faucet;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmF1Y2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdGVzdC9sb2NhbF9mdWxsbm9kZS9mYXVjZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsa0RBQTBCO0FBRTFCLE1BQWEsTUFBTTtJQUVqQixZQUFZLEdBQVc7UUFDckIsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7SUFDakIsQ0FBQztJQUVELEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBZSxFQUFFLE1BQWM7UUFDNUMsTUFBTSxlQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEdBQUcsTUFBTSxFQUFFLEVBQUUsa0JBQWtCLEVBQUUsRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3RGLENBQUM7Q0FDRjtBQVRELHdCQVNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGF4aW9zIGZyb20gJ2F4aW9zJztcblxuZXhwb3J0IGNsYXNzIEZhdWNldCB7XG4gIHB1YmxpYyB1cmw6IHN0cmluZztcbiAgY29uc3RydWN0b3IodXJsOiBzdHJpbmcpIHtcbiAgICB0aGlzLnVybCA9IHVybDtcbiAgfVxuXG4gIGFzeW5jIGdldENvaW5zKGFkZHJlc3M6IHN0cmluZywgYW1vdW50OiBudW1iZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBheGlvcy5wb3N0KHRoaXMudXJsICsgJy9nYXMnLCB7IEZpeGVkQW1vdW50UmVxdWVzdDogeyByZWNpcGllbnQ6IGFkZHJlc3MgfSB9KTtcbiAgfVxufVxuIl19

package/dist/test/local_fullnode/transactions.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transactions.d.ts.map

package/dist/test/local_fullnode/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../../test/local_fullnode/transactions.ts"],"names":[],"mappings":""}

package/dist/test/local_fullnode/transactions.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+process.env.DEBUG = 'RpcClient,SuiTransactionTypes';
+const assert_1 = __importDefault(require("assert"));
+const util_1 = __importDefault(require("util"));
+const faucet_1 = require("./faucet");
+const debug_1 = __importDefault(require("debug"));
+const crypto_1 = require("crypto");
+const src_1 = require("../../src");
+const RpcClient_1 = require("./RpcClient");
+const getBuilderFactory_1 = require("../unit/getBuilderFactory");
+const iface_1 = require("../../src/lib/iface");
+const constants_1 = require("../../src/lib/constants");
+const debug = (0, debug_1.default)('SuiTransactionTypes');
+async function getAllCoins(conn, address) {
+    return (await conn.getCoins(address)).data.map((v) => {
+        return {
+            digest: v.digest,
+            objectId: v.coinObjectId,
+            version: v.version,
+        };
+    });
+}
+/**
+ * @returns The stakes array with the stakedSui amount reduced by amount. If amount is undefined, the stakedSui is removed.
+ */
+function subtractStake(stakes, stakedSui, amount) {
+    return stakes.flatMap((s) => {
+        if (s.stakedSuiId === stakedSui.stakedSuiId) {
+            if (amount === undefined) {
+                // remove the stake
+                return [];
+            }
+            else {
+                // reduce the stake by amount
+                return [{ ...s, principal: Number(s.principal) - amount }];
+            }
+        }
+        else {
+            // keep the stake unchanged
+            return [s];
+        }
+    });
+}
+/**
+ * Asserts that the stakesAfter array is the same as the stakesBefore array with the stakedSui amount reduced by amount.
+ */
+function assertReducedStake(stakesBefore, stakesAfter, stakedSui, amount) {
+    /*
+     * Normalize the stake objects by converting the principal to a number and removing the estimatedReward.
+     */
+    function normStake(s) {
+        return { ...s, principal: Number(s.principal), estimatedReward: undefined };
+    }
+    stakesBefore = stakesBefore.map(normStake);
+    stakesAfter = stakesAfter.map(normStake);
+    assert_1.default.deepStrictEqual(stakesAfter, subtractStake(stakesBefore, stakedSui, amount));
+}
+async function getStakes(conn, owner, params = {}) {
+    const all = await conn.getStakes(owner);
+    const result = await Promise.all(all.flatMap((s) => s.stakes
+        .filter((v) => params.filterStatus === undefined || v.status === params.filterStatus)
+        .filter((v) => params.filterMinValue === undefined || params.filterMinValue <= Number(v.principal))));
+    if (result.length) {
+        return result;
+    }
+    const { attempts = 60, sleepMs = 1000 } = params;
+    if (0 < attempts) {
+        await new Promise((resolve) => setTimeout(resolve, sleepMs));
+        return await getStakes(conn, owner, { ...params, attempts: attempts - 1, sleepMs });
+    }
+    else {
+        throw new Error('getAllActiveStakedSuis: no active staked suis found');
+    }
+}
+async function resolveStakedSui(conn, stake) {
+    return (await conn.getObject(stake.stakedSuiId)).data;
+}
+function getKeyPair(seed) {
+    const seedBuf = (0, crypto_1.createHash)('sha256').update(seed).digest();
+    return new src_1.KeyPair({ seed: seedBuf });
+}
+async function signAndSubmit(conn, keyPair, txb) {
+    txb.sign({ key: keyPair.getKeys().prv });
+    const tx = (await txb.build());
+    debug('tx', util_1.default.inspect(tx.suiTransaction.tx, { depth: 10 }));
+    const result = await conn.executeTransactionBlock(tx.toBroadcastFormat(), [
+        Buffer.from(tx.serializedSig).toString('base64'),
+    ]);
+    if (result.effects?.status.status !== 'success') {
+        throw new Error(`Transaction failed: ${JSON.stringify(result.effects?.status)}`);
+    }
+}
+async function fundFromFaucet(url, v, amount = 100e9) {
+    if (typeof v !== 'string') {
+        v = v.getAddress();
+    }
+    await new faucet_1.Faucet(url).getCoins(v, 10e9);
+}
+describe('Sui Transaction Types', function () {
+    if (process.env.DRONE) {
+        console.log('skipping local_fullnode/transactions.ts on drone');
+        return;
+    }
+    const keyPair = getKeyPair('test');
+    const address = keyPair.getAddress();
+    debug('address', address);
+    const fullnodeUrl = process.env.SUI_FULLNODE_URL || 'http://127.0.0.1:9000';
+    const faucetUrl = process.env.SUI_FAUCET_URL || 'http://127.0.0.1:9123';
+    async function getDefaultGasData(keyPair) {
+        return {
+            owner: keyPair.getAddress(),
+            payment: await getAllCoins(conn, keyPair.getAddress()),
+            budget: 100000000,
+            price: constants_1.DUMMY_SUI_GAS_PRICE,
+        };
+    }
+    let conn;
+    let validator;
+    before('establish connection', async function () {
+        conn = await RpcClient_1.RpcClient.createCheckedConnection(fullnodeUrl);
+        const { apys } = await conn.getValidatorsApy();
+        validator = apys[0].address;
+    });
+    before('fund via faucet', async function () {
+        if (faucetUrl) {
+            await fundFromFaucet(faucetUrl, address);
+        }
+    });
+    it('has coins', async function () {
+        const { data } = await conn.getCoins(address);
+        assert_1.default.notStrictEqual(data.length, 0);
+    });
+    it('can transfer coins', async function () {
+        const builder = (0, getBuilderFactory_1.getBuilderFactory)('tsui').getTransferBuilder();
+        const txb = builder
+            .type(iface_1.SuiTransactionType.Transfer)
+            .sender(address)
+            .send([{ address, amount: (111111).toString() }])
+            .gasData(await getDefaultGasData(keyPair));
+        await signAndSubmit(conn, keyPair, txb);
+    });
+    async function stakeAmount(keyPair, amount) {
+        const builder = (0, getBuilderFactory_1.getBuilderFactory)('tsui').getStakingBuilder();
+        const txb = builder
+            .type(iface_1.SuiTransactionType.AddStake)
+            .sender(keyPair.getAddress())
+            .stake([{ amount, validatorAddress: validator }])
+            .gasData(await getDefaultGasData(keyPair));
+        await signAndSubmit(conn, keyPair, txb);
+    }
+    it('can stake coins', async function () {
+        await stakeAmount(keyPair, 1e9);
+    });
+    function testUnstake(amount) {
+        describe(`unstake (amount=${amount})`, function () {
+            const keyPairStakeTest = getKeyPair(`stake-test-amount-${amount !== undefined}`);
+            const address = keyPairStakeTest.getAddress();
+            before('stake coins', async function () {
+                await fundFromFaucet(faucetUrl, address);
+                await stakeAmount(keyPairStakeTest, 10e9);
+            });
+            it(`can unstake`, async function () {
+                const activeStakedSui = await getStakes(conn, address, {
+                    filterStatus: 'Active',
+                    filterMinValue: constants_1.MIN_STAKING_THRESHOLD + (amount || 0),
+                });
+                (0, assert_1.default)(activeStakedSui.length > 0, 'No staked coins found');
+                for (const stakedSui of activeStakedSui.slice(0, 3)) {
+                    debug('unstaking', stakedSui);
+                    const builder = (0, getBuilderFactory_1.getBuilderFactory)('tsui').getUnstakingBuilder();
+                    const stakedBefore = await getStakes(conn, address);
+                    const txb = builder
+                        .type(iface_1.SuiTransactionType.WithdrawStake)
+                        .sender(address)
+                        .unstake({ stakedSui: await resolveStakedSui(conn, stakedSui), amount })
+                        .gasData(await getDefaultGasData(keyPairStakeTest));
+                    await signAndSubmit(conn, keyPairStakeTest, txb);
+                    assertReducedStake(stakedBefore, await getStakes(conn, address), stakedSui, amount);
+                }
+            });
+        });
+    }
+    testUnstake(undefined);
+    testUnstake(1e9);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactions.js","sourceRoot":"","sources":["../../../test/local_fullnode/transactions.ts"],"names":[],"mappings":";;;;;AAEA,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,+BAA+B,CAAC;AAEpD,oDAA4B;AAC5B,gDAAwB;AACxB,qCAAkC;AAClC,kDAA+B;AAC/B,mCAAoC;AAEpC,mCAQmB;AACnB,2CAAwC;AACxC,iEAA8D;AAC9D,+CAAyD;AAEzD,uDAAqF;AAErF,MAAM,KAAK,GAAG,IAAA,eAAU,EAAC,qBAAqB,CAAC,CAAC;AAEhD,KAAK,UAAU,WAAW,CAAC,IAAe,EAAE,OAAe;IACzD,OAAO,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACnD,OAAO;YACL,MAAM,EAAE,CAAC,CAAC,MAAM;YAChB,QAAQ,EAAE,CAAC,CAAC,YAAY;YACxB,OAAO,EAAE,CAAC,CAAC,OAAO;SACnB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,aAAa,CAAC,MAAqB,EAAE,SAAsB,EAAE,MAA0B;IAC9F,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAiB,EAAE;QACzC,IAAI,CAAC,CAAC,WAAW,KAAK,SAAS,CAAC,WAAW,EAAE,CAAC;YAC5C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,mBAAmB;gBACnB,OAAO,EAAE,CAAC;YACZ,CAAC;iBAAM,CAAC;gBACN,6BAA6B;gBAC7B,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC;YAC7D,CAAC;QACH,CAAC;aAAM,CAAC;YACN,2BAA2B;YAC3B,OAAO,CAAC,CAAC,CAAC,CAAC;QACb,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,kBAAkB,CACzB,YAA2B,EAC3B,WAA0B,EAC1B,SAAsB,EACtB,MAA0B;IAE1B;;OAEG;IACH,SAAS,SAAS,CAAC,CAAc;QAC/B,OAAO,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;IAC9E,CAAC;IACD,YAAY,GAAG,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC3C,WAAW,GAAG,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACzC,gBAAM,CAAC,eAAe,CAAC,WAAW,EAAE,aAAa,CAAC,YAAY,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,KAAK,UAAU,SAAS,CACtB,IAAe,EACf,KAAa,EACb,SAKI,EAAE;IAEN,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAChB,CAAC,CAAC,MAAM;SACL,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,YAAY,CAAC;SACpF,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,KAAK,SAAS,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CACtG,CACF,CAAC;IACF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,EAAE,QAAQ,GAAG,EAAE,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;IACjD,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC;QACjB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QAC7D,OAAO,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IACtF,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;AACH,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,IAAe,EAAE,KAAkB;IACjE,OAAO,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;AACxD,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,MAAM,OAAO,GAAG,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3D,OAAO,IAAI,aAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AACxC,CAAC;AAED,KAAK,UAAU,aAAa,CAC1B,IAAe,EACf,OAAgB,EAChB,GAAwD;IAExD,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACzC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK,EAAE,CAAoE,CAAC;IAClG,KAAK,CAAC,IAAI,EAAE,cAAI,CAAC,OAAO,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,EAAE,CAAC,iBAAiB,EAAE,EAAE;QACxE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;KACjD,CAAC,CAAC;IACH,IAAI,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IACnF,CAAC;AACH,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,GAAW,EAAE,CAAmB,EAAE,MAAM,GAAG,KAAK;IAC5E,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC;IACrB,CAAC;IACD,MAAM,IAAI,eAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED,QAAQ,CAAC,uBAAuB,EAAE;IAChC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;QACtB,OAAO,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;QAChE,OAAO;IACT,CAAC;IAED,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IACrC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAE1B,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,uBAAuB,CAAC;IAC5E,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,uBAAuB,CAAC;IAExE,KAAK,UAAU,iBAAiB,CAAC,OAAgB;QAC/C,OAAO;YACL,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;YAC3B,OAAO,EAAE,MAAM,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC;YACtD,MAAM,EAAE,SAAW;YACnB,KAAK,EAAE,+BAAmB;SAC3B,CAAC;IACJ,CAAC;IAED,IAAI,IAAe,CAAC;IACpB,IAAI,SAAiB,CAAC;IACtB,MAAM,CAAC,sBAAsB,EAAE,KAAK;QAClC,IAAI,GAAG,MAAM,qBAAS,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;QAC5D,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC/C,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAC9B,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,iBAAiB,EAAE,KAAK;QAC7B,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,cAAc,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,WAAW,EAAE,KAAK;QACnB,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC9C,gBAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oBAAoB,EAAE,KAAK;QAC5B,MAAM,OAAO,GAAG,IAAA,qCAAiB,EAAC,MAAM,CAAC,CAAC,kBAAkB,EAAE,CAAC;QAC/D,MAAM,GAAG,GAAG,OAAO;aAChB,IAAI,CAAC,0BAAkB,CAAC,QAAQ,CAAC;aACjC,MAAM,CAAC,OAAO,CAAC;aACf,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,MAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;aACjD,OAAO,CAAC,MAAM,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAE7C,MAAM,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,KAAK,UAAU,WAAW,CAAC,OAAgB,EAAE,MAAc;QACzD,MAAM,OAAO,GAAG,IAAA,qCAAiB,EAAC,MAAM,CAAC,CAAC,iBAAiB,EAAE,CAAC;QAC9D,MAAM,GAAG,GAAG,OAAO;aAChB,IAAI,CAAC,0BAAkB,CAAC,QAAQ,CAAC;aACjC,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;aAC5B,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAE,CAAC,CAAC;aAChD,OAAO,CAAC,MAAM,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAE7C,MAAM,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC;IAED,EAAE,CAAC,iBAAiB,EAAE,KAAK;QACzB,MAAM,WAAW,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,SAAS,WAAW,CAAC,MAA0B;QAC7C,QAAQ,CAAC,mBAAmB,MAAM,GAAG,EAAE;YACrC,MAAM,gBAAgB,GAAG,UAAU,CAAC,qBAAqB,MAAM,KAAK,SAAS,EAAE,CAAC,CAAC;YACjF,MAAM,OAAO,GAAG,gBAAgB,CAAC,UAAU,EAAE,CAAC;YAE9C,MAAM,CAAC,aAAa,EAAE,KAAK;gBACzB,MAAM,cAAc,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBACzC,MAAM,WAAW,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,aAAa,EAAE,KAAK;gBACrB,MAAM,eAAe,GAAG,MAAM,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE;oBACrD,YAAY,EAAE,QAAQ;oBACtB,cAAc,EAAE,iCAAqB,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;iBACtD,CAAC,CAAC;gBACH,IAAA,gBAAM,EAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,uBAAuB,CAAC,CAAC;gBAE5D,KAAK,MAAM,SAAS,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;oBACpD,KAAK,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;oBAC9B,MAAM,OAAO,GAAG,IAAA,qCAAiB,EAAC,MAAM,CAAC,CAAC,mBAAmB,EAAE,CAAC;oBAChE,MAAM,YAAY,GAAG,MAAM,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;oBACpD,MAAM,GAAG,GAAG,OAAO;yBAChB,IAAI,CAAC,0BAAkB,CAAC,aAAa,CAAC;yBACtC,MAAM,CAAC,OAAO,CAAC;yBACf,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;yBACvE,OAAO,CAAC,MAAM,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,CAAC;oBACtD,MAAM,aAAa,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,CAAC,CAAC;oBAEjD,kBAAkB,CAAC,YAAY,EAAE,MAAM,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;gBACtF,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,SAAS,CAAC,CAAC;IACvB,WAAW,CAAC,GAAG,CAAC,CAAC;AACnB,CAAC,CAAC,CAAC","sourcesContent":["import { StakeObject } from '../../src/lib/mystenlab/types/validator';\n\nprocess.env.DEBUG = 'RpcClient,SuiTransactionTypes';\n\nimport assert from 'assert';\nimport util from 'util';\nimport { Faucet } from './faucet';\nimport buildDebug from 'debug';\nimport { createHash } from 'crypto';\n\nimport {\n  KeyPair,\n  StakingBuilder,\n  StakingTransaction,\n  TransferBuilder,\n  TransferTransaction,\n  UnstakingBuilder,\n  UnstakingTransaction,\n} from '../../src';\nimport { RpcClient } from './RpcClient';\nimport { getBuilderFactory } from '../unit/getBuilderFactory';\nimport { SuiTransactionType } from '../../src/lib/iface';\nimport { GasData, SuiObjectRef } from '../../src/lib/mystenlab/types';\nimport { DUMMY_SUI_GAS_PRICE, MIN_STAKING_THRESHOLD } from '../../src/lib/constants';\n\nconst debug = buildDebug('SuiTransactionTypes');\n\nasync function getAllCoins(conn: RpcClient, address: string): Promise<SuiObjectRef[]> {\n  return (await conn.getCoins(address)).data.map((v) => {\n    return {\n      digest: v.digest,\n      objectId: v.coinObjectId,\n      version: v.version,\n    };\n  });\n}\n\n/**\n * @returns The stakes array with the stakedSui amount reduced by amount. If amount is undefined, the stakedSui is removed.\n */\nfunction subtractStake(stakes: StakeObject[], stakedSui: StakeObject, amount: number | undefined): StakeObject[] {\n  return stakes.flatMap((s): StakeObject[] => {\n    if (s.stakedSuiId === stakedSui.stakedSuiId) {\n      if (amount === undefined) {\n        // remove the stake\n        return [];\n      } else {\n        // reduce the stake by amount\n        return [{ ...s, principal: Number(s.principal) - amount }];\n      }\n    } else {\n      // keep the stake unchanged\n      return [s];\n    }\n  });\n}\n\n/**\n * Asserts that the stakesAfter array is the same as the stakesBefore array with the stakedSui amount reduced by amount.\n */\nfunction assertReducedStake(\n  stakesBefore: StakeObject[],\n  stakesAfter: StakeObject[],\n  stakedSui: StakeObject,\n  amount: number | undefined\n) {\n  /*\n   * Normalize the stake objects by converting the principal to a number and removing the estimatedReward.\n   */\n  function normStake(s: StakeObject): StakeObject {\n    return { ...s, principal: Number(s.principal), estimatedReward: undefined };\n  }\n  stakesBefore = stakesBefore.map(normStake);\n  stakesAfter = stakesAfter.map(normStake);\n  assert.deepStrictEqual(stakesAfter, subtractStake(stakesBefore, stakedSui, amount));\n}\n\nasync function getStakes(\n  conn: RpcClient,\n  owner: string,\n  params: {\n    filterStatus?: StakeObject['status'];\n    filterMinValue?: number;\n    attempts?: number;\n    sleepMs?: number;\n  } = {}\n): Promise<StakeObject[]> {\n  const all = await conn.getStakes(owner);\n  const result = await Promise.all(\n    all.flatMap((s) =>\n      s.stakes\n        .filter((v) => params.filterStatus === undefined || v.status === params.filterStatus)\n        .filter((v) => params.filterMinValue === undefined || params.filterMinValue <= Number(v.principal))\n    )\n  );\n  if (result.length) {\n    return result;\n  }\n  const { attempts = 60, sleepMs = 1000 } = params;\n  if (0 < attempts) {\n    await new Promise((resolve) => setTimeout(resolve, sleepMs));\n    return await getStakes(conn, owner, { ...params, attempts: attempts - 1, sleepMs });\n  } else {\n    throw new Error('getAllActiveStakedSuis: no active staked suis found');\n  }\n}\n\nasync function resolveStakedSui(conn: RpcClient, stake: StakeObject): Promise<SuiObjectRef> {\n  return (await conn.getObject(stake.stakedSuiId)).data;\n}\n\nfunction getKeyPair(seed: string): KeyPair {\n  const seedBuf = createHash('sha256').update(seed).digest();\n  return new KeyPair({ seed: seedBuf });\n}\n\nasync function signAndSubmit(\n  conn: RpcClient,\n  keyPair: KeyPair,\n  txb: TransferBuilder | StakingBuilder | UnstakingBuilder\n): Promise<void> {\n  txb.sign({ key: keyPair.getKeys().prv });\n  const tx = (await txb.build()) as TransferTransaction | StakingTransaction | UnstakingTransaction;\n  debug('tx', util.inspect(tx.suiTransaction.tx, { depth: 10 }));\n  const result = await conn.executeTransactionBlock(tx.toBroadcastFormat(), [\n    Buffer.from(tx.serializedSig).toString('base64'),\n  ]);\n  if (result.effects?.status.status !== 'success') {\n    throw new Error(`Transaction failed: ${JSON.stringify(result.effects?.status)}`);\n  }\n}\n\nasync function fundFromFaucet(url: string, v: KeyPair | string, amount = 100e9): Promise<void> {\n  if (typeof v !== 'string') {\n    v = v.getAddress();\n  }\n  await new Faucet(url).getCoins(v, 10e9);\n}\n\ndescribe('Sui Transaction Types', function () {\n  if (process.env.DRONE) {\n    console.log('skipping local_fullnode/transactions.ts on drone');\n    return;\n  }\n\n  const keyPair = getKeyPair('test');\n  const address = keyPair.getAddress();\n  debug('address', address);\n\n  const fullnodeUrl = process.env.SUI_FULLNODE_URL || 'http://127.0.0.1:9000';\n  const faucetUrl = process.env.SUI_FAUCET_URL || 'http://127.0.0.1:9123';\n\n  async function getDefaultGasData(keyPair: KeyPair): Promise<GasData> {\n    return {\n      owner: keyPair.getAddress(),\n      payment: await getAllCoins(conn, keyPair.getAddress()),\n      budget: 100_000_000,\n      price: DUMMY_SUI_GAS_PRICE,\n    };\n  }\n\n  let conn: RpcClient;\n  let validator: string;\n  before('establish connection', async function () {\n    conn = await RpcClient.createCheckedConnection(fullnodeUrl);\n    const { apys } = await conn.getValidatorsApy();\n    validator = apys[0].address;\n  });\n\n  before('fund via faucet', async function () {\n    if (faucetUrl) {\n      await fundFromFaucet(faucetUrl, address);\n    }\n  });\n\n  it('has coins', async function () {\n    const { data } = await conn.getCoins(address);\n    assert.notStrictEqual(data.length, 0);\n  });\n\n  it('can transfer coins', async function () {\n    const builder = getBuilderFactory('tsui').getTransferBuilder();\n    const txb = builder\n      .type(SuiTransactionType.Transfer)\n      .sender(address)\n      .send([{ address, amount: (111_111).toString() }])\n      .gasData(await getDefaultGasData(keyPair));\n\n    await signAndSubmit(conn, keyPair, txb);\n  });\n\n  async function stakeAmount(keyPair: KeyPair, amount: number): Promise<void> {\n    const builder = getBuilderFactory('tsui').getStakingBuilder();\n    const txb = builder\n      .type(SuiTransactionType.AddStake)\n      .sender(keyPair.getAddress())\n      .stake([{ amount, validatorAddress: validator }])\n      .gasData(await getDefaultGasData(keyPair));\n\n    await signAndSubmit(conn, keyPair, txb);\n  }\n\n  it('can stake coins', async function () {\n    await stakeAmount(keyPair, 1e9);\n  });\n\n  function testUnstake(amount: number | undefined) {\n    describe(`unstake (amount=${amount})`, function () {\n      const keyPairStakeTest = getKeyPair(`stake-test-amount-${amount !== undefined}`);\n      const address = keyPairStakeTest.getAddress();\n\n      before('stake coins', async function () {\n        await fundFromFaucet(faucetUrl, address);\n        await stakeAmount(keyPairStakeTest, 10e9);\n      });\n\n      it(`can unstake`, async function () {\n        const activeStakedSui = await getStakes(conn, address, {\n          filterStatus: 'Active',\n          filterMinValue: MIN_STAKING_THRESHOLD + (amount || 0),\n        });\n        assert(activeStakedSui.length > 0, 'No staked coins found');\n\n        for (const stakedSui of activeStakedSui.slice(0, 3)) {\n          debug('unstaking', stakedSui);\n          const builder = getBuilderFactory('tsui').getUnstakingBuilder();\n          const stakedBefore = await getStakes(conn, address);\n          const txb = builder\n            .type(SuiTransactionType.WithdrawStake)\n            .sender(address)\n            .unstake({ stakedSui: await resolveStakedSui(conn, stakedSui), amount })\n            .gasData(await getDefaultGasData(keyPairStakeTest));\n          await signAndSubmit(conn, keyPairStakeTest, txb);\n\n          assertReducedStake(stakedBefore, await getStakes(conn, address), stakedSui, amount);\n        }\n      });\n    });\n  }\n\n  testUnstake(undefined);\n  testUnstake(1e9);\n});\n"]}