@tari-project/tarijs 0.4.0 → 0.4.2

package/docusaurus/tari-docs/docs/wallet/get-substate.md

@@ -0,0 +1,110 @@
+---
+sidebar_position: 4
+---
+
+# Get substate
+
+It is possible to get substate details by substate address:
+
+```js
+const substateAddress = "component_9cdad1188895b080885a64abb71a66a4a4cb1d8117679d85c8b35a4ec5d02243";
+const substate = await provider.getSubstate(substateAddress);
+```
+
+```json
+{
+  "value": {
+    "substate": {
+      "Component": {
+        "access_rules": {
+          "default": "AllowAll",
+          "method_access": {}
+        },
+        "body": {
+          "state": {
+            "Map": [
+              [
+                {
+                  "Text": "vault"
+                },
+                {
+                  "Tag": [
+                    132,
+                    {
+                      "Bytes": [
+                        156,
+                        218,
+                        209,
+                        24,
+                        136,
+                        149,
+                        176,
+                        128,
+                        136,
+                        90,
+                        100,
+                        171,
+                        183,
+                        26,
+                        102,
+                        164,
+                        164,
+                        203,
+                        29,
+                        129,
+                        22,
+                        248,
+                        9,
+                        1,
+                        100,
+                        31,
+                        71,
+                        132,
+                        87,
+                        88,
+                        252,
+                        4
+                      ]
+                    }
+                  ]
+                }
+              ]
+            ]
+          }
+        },
+        "entity_id": [
+          156,
+          218,
+          209,
+          24,
+          136,
+          149,
+          176,
+          128,
+          136,
+          90,
+          100,
+          171,
+          183,
+          26,
+          102,
+          164,
+          164,
+          203,
+          29,
+          129
+        ],
+        "module_name": "TestFaucet",
+        "owner_key": "a6534c991a5c034b2f81af809b9577fe6b5425f810de292c0a4d4d43793a8f50",
+        "owner_rule": "OwnedBySigner",
+        "template_address": "20a814546424dae7496451a170325ddaed52d118e4fcf46c1abd32b3d6ee8163"
+      }
+    },
+    "version": 0
+  },
+  "address": {
+    "substate_id": "component_9cdad1188895b080885a64abb71a66a4a4cb1d8117679d85c8b35a4ec5d02243",
+    "version": 0
+  }
+}
+```

package/docusaurus/tari-docs/docs/wallet/list-substates.md

@@ -0,0 +1,69 @@
+---
+sidebar_position: 3
+---
+
+# List substates
+
+In the Tari network, substates are discrete units of state within the Tari Digital Assets Network. Each substate encapsulates a specific piece of data—such as ownership records, smart contract states, or asset balances.  
+Substates follow a create-spend lifecycle, meaning they are created, referenced, and eventually consumed or modified according to network rules.
+
+You can query substates using the `listSubstates` method of a `TariProvider`.
+
+```ts
+listSubstates(
+  filter_by_template: string | null,
+  filter_by_type: SubstateType | null,
+  limit: number | null,
+  offset: number | null
+): Promise<ListSubstatesResponse>;
+```
+
+
+## List by template
+
+```js
+const accountTemplate = "0000000000000000000000000000000000000000000000000000000000000000";
+const accountSubstates = await provider.listSubstates(accountTemplate, null, 1, 0);
+```
+
+The result could be similar to:
+
+```json
+{
+  "substates": [
+    {
+      "substate_id": "component_24b679b98056c7ca7e3d9f9266fec928c7f29d35e7aec546ed69f532aff40710",
+      "module_name": "Account",
+      "version": 3,
+      "template_address": "0000000000000000000000000000000000000000000000000000000000000000"
+    }
+  ]
+}
+```
+
+## List by substate type
+
+```js
+const accountSubstatesByType = await provider.listSubstates(null, "Component", 2, 0);
+```
+
+Output:
+
+```json
+{
+  "substates": [
+    {
+      "substate_id": "component_24b679b98056c7ca7e3d9f9266fec928c7f29d35e7aec546ed69f532aff40710",
+      "module_name": "Account",
+      "version": 3,
+      "template_address": "0000000000000000000000000000000000000000000000000000000000000000"
+    },
+    {
+      "substate_id": "component_1120a9ce46a820a955580cd7d07ee6b93a2ce16ee1671e4dcefd72dfbd33a168",
+      "module_name": "TariswapIndex",
+      "version": 1,
+      "template_address": "60041a6b62a9aa5dbbcc99d8be3ac59765f619c522fd387906dd30c9a9a78d3f"
+    }
+  ]
+}
+```

package/docusaurus/tari-docs/docs/wallet/submit-transaction/_category_.json

@@ -0,0 +1,8 @@
+{
+  "label": "Submit transaction",
+  "position": 5,
+  "link": {
+    "type": "doc",
+    "id": "transactions-index"
+  }
+}

package/docusaurus/tari-docs/docs/wallet/submit-transaction/build-execute-request.md

@@ -0,0 +1,38 @@
+---
+sidebar_position: 2
+---
+
+# Build and execute a request
+
+## Build a transaction
+
+After constructing an instance of the *Transaction Builder*, you can build a transaction as follows:
+
+```js
+const transaction = builder.build();
+```
+
+## Build a transaction request
+
+The transaction request has additional parameters. Therefore, you build it using `buildTransactionRequest`:
+
+```js
+const isDryRun = false;
+const inputRefs = undefined; // Obsolete
+const network = Network.LocalNet;
+const requiredSubstates = []; // Soon to be retired. Use `builder.withInputs()` instead.
+const submitTransactionRequest = buildTransactionRequest(
+  transaction,
+  account.account_id,
+  requiredSubstates,
+  inputRefs,
+  isDryRun,
+  network
+);
+```
+
+## Execute a transaction
+
+```js
+const txResult = await submitAndWaitForTransaction(provider, submitTransactionRequest);
+```

package/docusaurus/tari-docs/docs/wallet/submit-transaction/index.md

@@ -0,0 +1,14 @@
+---
+id: transactions-index
+title: Submit Transaction
+description: A detailed explanation of submitting transactions.
+---
+
+# Submit transaction
+
+The provider exposes the `submitTransaction` and `getTransactionResult` methods. The first submits the transaction, while the second polls the current status of the transaction using its ID. These methods are low-level, so it is recommended to use the transaction builder and other helpers instead.
+
+```ts
+submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
+getTransactionResult(transactionId: string): Promise<TransactionResult>;
+```

package/docusaurus/tari-docs/docs/wallet/submit-transaction/transaction-builder/_category_.json

@@ -0,0 +1,8 @@
+{
+  "label": "Transaction Builder",
+  "position": 1,
+  "link": {
+    "type": "doc",
+    "id": "transaction-builder-index"
+  }
+}

package/docusaurus/tari-docs/docs/wallet/submit-transaction/transaction-builder/call-function.md

@@ -0,0 +1,17 @@
+---
+sidebar_position: 5
+---
+
+# CallFunction
+
+`callFunction` can be used to create instances of components or call other *static* methods.
+
+```js
+builder = builder.callFunction(
+  {
+    templateAddress,
+    functionName: "new",
+  },
+  [1, 2, 3]
+);
+```

package/docusaurus/tari-docs/docs/wallet/submit-transaction/transaction-builder/call-method.md

@@ -0,0 +1,17 @@
+---
+sidebar_position: 5
+---
+
+# CallMethod
+
+`callMethod` calls a method on an instance of a template—in other words, on a component.
+
+```js
+const amount = 10;
+const tokenResource = "resource_217d58767480fbaa48693e11de34baf7fd727e33ee7627f0c4e5b78def378e57";
+  
+builder = builder.callMethod({
+    componentAddress: account.address,
+    methodName: "withdraw",
+}, [tokenResource, amount.toString()]);
+```

package/docusaurus/tari-docs/docs/wallet/submit-transaction/transaction-builder/fee.md

@@ -0,0 +1,28 @@
+---
+sidebar_position: 4
+---
+
+# Fee
+
+Executing a transaction requires a fee. This fee can originate from sources other than the transaction sender's account.
+
+```js
+const account = await provider.getAccount();
+const fee = new Amount(2000);
+builder = builder
+  .feeTransactionPayFromComponent(account.address, fee.getStringValue());
+```
+
+Under the hood, `feeTransactionPayFromComponent` creates an instruction that calls the `pay_fee` method on a component.
+
+```js
+builder.addFeeInstruction({
+  CallMethod: {
+    component_address: componentAddress,
+    method: "pay_fee",
+    args: [maxFee],
+  },
+});
+```
+
+You might need to take this explicit route if the fee payment method is named something other than `pay_fee`.