@d9-network/ink 0.0.1

package/test/ink.test.ts

@@ -0,0 +1,404 @@
+import { beforeAll, afterAll, describe, it, expect } from "bun:test";
+import { Binary, type SS58String, createClient, type CreateClientOptions } from "polkadot-api";
+import { getPolkadotSigner } from "polkadot-api/signer";
+import { getWsProvider } from "polkadot-api/ws-provider";
+import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
+import { withLegacy } from "@polkadot-api/legacy-provider";
+import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
+import { entropyToMiniSecret, mnemonicToEntropy, ss58Decode } from "@polkadot-labs/hdkd-helpers";
+import { AccountId } from "@polkadot-api/substrate-bindings";
+import { contracts, d9, getMetadata } from "@polkadot-api/descriptors";
+import { createD9InkSdk, type D9InkContractFromDescriptor } from "../src";
+
+const TEST_ADDRESSES = {
+  testUser: "zcb3U8vYqWLmd5huhyS7nMiMnqDQfWJrmjQcpMhkWmn7krH",
+  usdtContract: "uLj9DRUujbpCyK7USZY5ebGbxdtKoWvdRvGyyUsoLWDsNng",
+};
+
+const ENDPOINT = process.env.TEST_ENDPOINT || "wss://mainnet.d9network.com:40300";
+
+// Get SS58 prefix from existing address (D9 network prefix)
+const [, D9_SS58_PREFIX] = ss58Decode(TEST_ADDRESSES.testUser);
+
+// Create AccountId codec with D9 prefix for encoding addresses
+const d9AccountId = AccountId(D9_SS58_PREFIX);
+
+/**
+ * Create a signer from mnemonic for testing
+ */
+function createSignerFromMnemonic(mnemonic: string) {
+  const entropy = mnemonicToEntropy(mnemonic);
+  const miniSecret = entropyToMiniSecret(entropy);
+  const derive = sr25519CreateDerive(miniSecret);
+  const keyPair = derive("");
+  const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
+
+  // Encode address with D9 prefix
+  const address = d9AccountId.dec(keyPair.publicKey) as SS58String;
+
+  return { signer, publicKey: keyPair.publicKey, address };
+}
+
+type CreateInkSdkClientOptions = {
+  endpoint: string;
+  wsProvider?: Parameters<typeof getWsProvider>[1];
+  metadata?: CreateClientOptions;
+};
+
+function createInkSdkClient(options: CreateInkSdkClientOptions) {
+  const provider = getWsProvider(options.endpoint, {
+    innerEnhancer: withLegacy(),
+    ...options.wsProvider,
+  });
+
+  const client = createClient(withPolkadotSdkCompat(provider), {
+    ...options.metadata,
+    async getMetadata(codeHash) {
+      // Prefer upstream metadata if present, otherwise fallback to embedded descriptors metadata.
+      const custom = options.metadata?.getMetadata
+        ? await options.metadata.getMetadata(codeHash)
+        : null;
+      if (custom) return custom;
+      const metadata = await getMetadata(codeHash);
+      return metadata ?? null;
+    },
+  });
+
+  const api = client.getTypedApi(d9);
+  const inkSdk = createD9InkSdk(client, { typedApi: api });
+
+  return {
+    client,
+    api,
+    inkSdk,
+  };
+}
+
+type InkSdkClientReturn = ReturnType<typeof createInkSdkClient>;
+
+const NETWORK_TIMEOUT = 30000;
+
+describe("D9 Ink SDK", () => {
+  let d9Client: InkSdkClientReturn;
+  let usdtContract: D9InkContractFromDescriptor<typeof contracts.usdt>;
+
+  beforeAll(async () => {
+    d9Client = createInkSdkClient({
+      endpoint: ENDPOINT,
+    });
+    usdtContract = d9Client.inkSdk.getContract(contracts.usdt, TEST_ADDRESSES.usdtContract);
+  });
+
+  afterAll(() => {
+    d9Client.client.destroy();
+  });
+
+  describe("USDT Contract Queries", () => {
+    it(
+      "should query PSP22::balance_of",
+      async () => {
+        const result = await usdtContract.query("PSP22::balance_of", {
+          origin: TEST_ADDRESSES.testUser,
+          args: { owner: TEST_ADDRESSES.testUser },
+        });
+
+        console.log("Query result:", result);
+
+        expect(result.success).toBe(true);
+        if (result.success) {
+          console.log("Balance:", result.value);
+          console.log("Gas consumed:", result.gasConsumed);
+          console.log("Gas required:", result.gasRequired);
+          expect(typeof result.value).toBe("bigint");
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+
+    it(
+      "should query PSP22::total_supply",
+      async () => {
+        const result = await usdtContract.query("PSP22::total_supply", {
+          origin: TEST_ADDRESSES.testUser,
+        });
+
+        console.log("Total supply result:", result);
+
+        expect(result.success).toBe(true);
+        if (result.success) {
+          console.log("Total supply:", result.value);
+          expect(typeof result.value).toBe("bigint");
+          expect(result.value).toBeGreaterThan(0n);
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+
+    it(
+      "should query PSP22::allowance",
+      async () => {
+        const result = await usdtContract.query("PSP22::allowance", {
+          origin: TEST_ADDRESSES.testUser,
+          args: {
+            owner: TEST_ADDRESSES.testUser,
+            spender: TEST_ADDRESSES.usdtContract,
+          },
+        });
+
+        console.log("Allowance result:", result);
+
+        expect(result.success).toBe(true);
+        if (result.success) {
+          console.log("Allowance:", result.value);
+          expect(typeof result.value).toBe("bigint");
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+  });
+
+  describe("Query Result Features", () => {
+    it(
+      "should include gas information in query result",
+      async () => {
+        const result = await usdtContract.query("PSP22::balance_of", {
+          origin: TEST_ADDRESSES.testUser,
+          args: { owner: TEST_ADDRESSES.testUser },
+        });
+
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.gasConsumed).toBeDefined();
+          expect(result.gasConsumed.refTime).toBeGreaterThan(0n);
+          expect(result.gasRequired).toBeDefined();
+          expect(result.gasRequired.refTime).toBeGreaterThan(0n);
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+
+    it(
+      "should provide send() method on query result",
+      async () => {
+        const result = await usdtContract.query("PSP22::balance_of", {
+          origin: TEST_ADDRESSES.testUser,
+          args: { owner: TEST_ADDRESSES.testUser },
+        });
+
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(typeof result.send).toBe("function");
+          const sendable = result.send();
+          expect(typeof sendable.signAndSubmit).toBe("function");
+          expect(typeof sendable.getEncodedData).toBe("function");
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+  });
+
+  describe("Send Transaction (Dry Run)", () => {
+    it(
+      "should create sendable transaction for PSP22::transfer",
+      async () => {
+        const sendable = usdtContract.send("PSP22::transfer", {
+          origin: TEST_ADDRESSES.testUser,
+          args: {
+            to: TEST_ADDRESSES.usdtContract,
+            value: 0n,
+            data: Binary.fromBytes(new Uint8Array(0)),
+          },
+        });
+
+        expect(sendable).toBeDefined();
+        expect(typeof sendable.signAndSubmit).toBe("function");
+        expect(typeof sendable.getEncodedData).toBe("function");
+
+        // Verify encoded data is generated
+        const encodedData = sendable.getEncodedData();
+        expect(encodedData).toBeInstanceOf(Uint8Array);
+        expect(encodedData.length).toBeGreaterThan(0);
+
+        console.log("Encoded transfer data length:", encodedData.length);
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+
+    it(
+      "should create sendable transaction for PSP22::approve",
+      async () => {
+        const sendable = usdtContract.send("PSP22::approve", {
+          origin: TEST_ADDRESSES.testUser,
+          args: {
+            spender: TEST_ADDRESSES.usdtContract,
+            value: 1000n,
+          },
+        });
+
+        expect(sendable).toBeDefined();
+        const encodedData = sendable.getEncodedData();
+        expect(encodedData).toBeInstanceOf(Uint8Array);
+        expect(encodedData.length).toBeGreaterThan(0);
+
+        console.log("Encoded approve data length:", encodedData.length);
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+  });
+
+  describe("Contract Instance Properties", () => {
+    it("should have correct contract address", () => {
+      expect(usdtContract.address).toBe(TEST_ADDRESSES.usdtContract);
+    });
+
+    it("should have metadata", () => {
+      expect(usdtContract.metadata).toBeDefined();
+      expect(usdtContract.metadata.spec).toBeDefined();
+      expect(usdtContract.metadata.spec.messages).toBeDefined();
+      expect(usdtContract.metadata.spec.messages.length).toBeGreaterThan(0);
+    });
+
+    it("should have getStorage method", () => {
+      const storage = usdtContract.getStorage();
+      expect(storage).toBeDefined();
+      expect(typeof storage.getRoot).toBe("function");
+      expect(typeof storage.getNested).toBe("function");
+    });
+
+    it("should have filterEvents method", () => {
+      expect(typeof usdtContract.filterEvents).toBe("function");
+    });
+  });
+
+  describe("Multiple Queries Consistency", () => {
+    it(
+      "should return consistent results for same query",
+      async () => {
+        const result1 = await usdtContract.query("PSP22::balance_of", {
+          origin: TEST_ADDRESSES.testUser,
+          args: { owner: TEST_ADDRESSES.testUser },
+        });
+
+        const result2 = await usdtContract.query("PSP22::balance_of", {
+          origin: TEST_ADDRESSES.testUser,
+          args: { owner: TEST_ADDRESSES.testUser },
+        });
+
+        expect(result1.success).toBe(true);
+        expect(result2.success).toBe(true);
+
+        if (result1.success && result2.success) {
+          expect(result1.value).toBe(result2.value);
+        }
+      },
+      { timeout: NETWORK_TIMEOUT },
+    );
+  });
+});
+
+// USDT token decimals (standard for USDT)
+const USDT_DECIMALS = 2n;
+
+/**
+ * Real transaction tests - only run when TEST_WALLET_MNEMONIC is set
+ */
+describe.skipIf(!process.env.TEST_WALLET_MNEMONIC)(
+  "USDT Real Transfer Test",
+  () => {
+  let d9Client: InkSdkClientReturn;
+  let usdtContract: D9InkContractFromDescriptor<typeof contracts.usdt>;
+  let wallet: ReturnType<typeof createSignerFromMnemonic>;
+
+  const TX_TIMEOUT = 120000; // 2 minutes for real transaction
+
+  beforeAll(async () => {
+    const mnemonic = process.env.TEST_WALLET_MNEMONIC!;
+    wallet = createSignerFromMnemonic(mnemonic);
+
+    console.log("Test wallet address:", wallet.address);
+
+    d9Client = createInkSdkClient({
+      endpoint: ENDPOINT,
+    });
+
+    usdtContract = d9Client.inkSdk.getContract(contracts.usdt, TEST_ADDRESSES.usdtContract);
+  });
+
+  afterAll(() => {
+    d9Client.client.destroy();
+  });
+
+  it(
+    "should transfer 0.01 USDT to self",
+    async () => {
+      // First, query current balance
+      const balanceBefore = await usdtContract.query("PSP22::balance_of", {
+        origin: wallet.address,
+        args: { owner: wallet.address },
+      });
+
+      expect(balanceBefore.success).toBe(true);
+      if (!balanceBefore.success) {
+        throw new Error(`Failed to query balance: ${balanceBefore.error}`);
+      }
+
+      // response is now directly bigint (MessageResult is unwrapped by SDK)
+      const currentBalance = balanceBefore.value;
+      const balanceInUsdt = Number(currentBalance) / Number(10n ** USDT_DECIMALS);
+
+      console.log("Balance before transfer:", currentBalance, `(${balanceInUsdt} USDT)`);
+      console.log("Transfer amount:", 0.01, `(0.01 USDT)`);
+
+      // Skip test if insufficient balance
+      if (currentBalance < 1) {
+        console.log(
+          `⚠️ Skipping transfer test: insufficient balance (need 0.01 USDT, have ${balanceInUsdt} USDT)`,
+        );
+        return;
+      }
+
+      // Perform dry-run first to get gas estimation
+      const queryResult = await usdtContract.query("PSP22::transfer", {
+        origin: wallet.address,
+        args: {
+          to: wallet.address,
+          value: 1n,
+          data: Binary.fromBytes(new Uint8Array(0)),
+        },
+      });
+
+      expect(queryResult.success).toBe(true);
+      if (!queryResult.success) {
+        throw new Error(`Transfer dry-run failed: ${queryResult.error}`);
+      }
+
+      console.log("Gas required:", queryResult.gasRequired);
+
+      // Execute real transfer using send() from query result
+      const txResult = await queryResult.send().signAndSubmit(wallet.signer);
+
+      console.log("Transaction result:", txResult);
+
+      expect(txResult.ok).toBe(true);
+      if (txResult.ok) {
+        console.log("Transaction hash:", txResult.txHash);
+        console.log("Block hash:", txResult.block.hash);
+        console.log("Block number:", txResult.block.number);
+      }
+
+      // Verify balance after (should be the same since we transferred to self)
+      const balanceAfter = await usdtContract.query("PSP22::balance_of", {
+        origin: wallet.address,
+        args: { owner: wallet.address },
+      });
+
+      expect(balanceAfter.success).toBe(true);
+      if (balanceAfter.success) {
+        console.log("Balance after transfer:", balanceAfter.value);
+        // Balance should remain the same (transfer to self)
+        expect(balanceAfter.value).toBe(balanceBefore.value);
+      }
+    },
+    { timeout: TX_TIMEOUT },
+  );
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noEmit": true,
+    "types": ["bun"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "test/**/*", "scripts/**/*"]
+}

package/tsdown.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsdown"
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  outDir: "./dist",
+  format: ["esm", "cjs"],
+  sourcemap: true,
+  clean: true,
+  dts: true,
+  exports: {
+    devExports: true
+  },
+})